at compile time.
Of course having a "no subclasses" tag means the compiler can change a
method call into a direct subroutine call, but I would hope that method
calling will be fast enough that it won't need to.
Will we require methods in subclasses to use the same signatures as the
methods they're overriding?
-Martin
--
4GL ... it's code Jim, but not as we know it.
On Mon, 15 Sep 2003, Dan Sugalski wrote:
> > Great. But will it also be possible to add methods (or modify them)
> > to an existing class at runtime?
>
> Unless the class has been explicitly closed, yes.
That strikes me as back-to-front.
The easy-to-optimise case should be the easy-to-type case;
ould
still need different syntaces, but has anyone else thought about this?
- Martin
that they should be overloadable on a per-arrayish-class
basis, no?
Then what happens to
@A = map { ! $_ } @B, @C;
when @B and @C are different classes?
Does that transmogrify into
@A = ( @B.map { ! $_ }, @C.map { ! $_ } )
or into
@A = [ @B, @C ] .map { ! $_ }
?
-Martin
inted out) for auto-vivification,
where the object doesn't exist before we operate on it.
Maybe we would get away with the shorthand "$ref[$index]" *except* where
autovivification is desired, and then we'd have to use the long-hand
"$ref@[$index]" and "$ref%[$index]" versions?
Hm, actually, I think I could class that as a feature, if the reader --
human or compiler -- could know just by looking whether auto-viv is expected.
-Martin
.e., not solvable).
Quite correct, my mistake.
Please read as s/NP-complete/halting problem/g
-Martin
On Fri, 20 Feb 2009, Timothy S. Nelson wrote:
> On Thu, 19 Feb 2009, Martin D Kealey wrote:
> > Rather, let's have immutable time "values", and methods which return other
> > "values" where various computations (*1) have been applied. Provide
> > c
() method private.
That's almost reasonable, but it assumes that eigenthreads don't work on
separate snapshot copies of the world, and that those snapshots aren't
discarded after their results are flattened by the junctive operator.
-Martin
z)any( $x OP $y, $x OP $z)
$x OP one($y,$z)one( $x OP $y, $x OP $z)
$x OP none($y,$z) none($x OP $y, $x OP $z)
-Martin
(*1: An argument could be made that "none" should leave the junction alone,
the same as "all".)
(*2: I would like to sugg
On behalf of the Rakudo development team, I'm pleased to announce the
February 2010 development release of Rakudo Perl #26 "Amsterdam".
Rakudo is an implementation of Perl 6 on the Parrot Virtual Machine
(see http://www.parrot.org). The tarball for the February 2010 release
is available from http:
It also makes me want to propose zsh-extended-glob-compatibility syntax
for objects so I can have method/attribute slices, and then I end up curled
up in a corner, scared and shaking.
But maybe I should just get used to that. :-)
> Juerd
Martin
ny(true,false))
* you-get-what-you-ask-for (return "PEBKAC":but(false) )
* a logical contradiction (return an unthrown exception)
* a formal error (throw an exception)
-Martin
whether either variable contains a junction?
As a start, perhaps we should be marking certain operators (not ! none() !=
ne) with whether they represent a logical inversion, so that conjunctions
and disjunctions can be alternated?
-Martin Kealey
at.uid, $stat.gid;
return;
}
if catching_exception(IO_error) {
throw IO_error(EPERM, $filename, "Can't give file away");
}
}
# can't (or don't need to) give file away
POSIX::chmod $filename, Fcntl::ST_PERM($stat.mode);
POSIX::utime $filename, $stat.mtime, $stat.atime;
}
-Martin
so happens to be an apposite
abbreviation. :-)
-Martin
er threads or coroutines)
* deep auto-cloning mutable "container" objects into immutable "value"
ones
* auto-boxing immutable "value" objects into "container" objects
-Martin
(*1: Google for the report by G Y Matthews (Sydney University, 1994) on
reformulating the "Magma" mathematical research language as an applicative
language.)
On Mon, 16 Feb 2009, Jon Lang wrote:
> if there's any doubt about the matter (e.g., conclusively proving or
> disproving purity would be NP-complete or a halting problem), then
Deciding whether you have a halting problem IS a halting problem... :-)
-Martin
arantee that they won't get mangled, so they can later be passed to more
pure code (*2).
Question: does/should MMD differentiate between :ro and :rw parameters or
invocants that are otherwise identical?
-Martin
*1: actually it's a bit more complicated; a mutable object can be re-
($odbc_handle) );
my &gmtime= DateTime::Gregorian.localize( :utc );
my &swatch= DateTime::Gregorian.localize( :tz('Europe/Geneva'), :no_dst );
-Martin
*1: Operations on localtime objects involve differences, offsets and
baselines, expressed in a range of units.
The core units are
s (which
must believe fiction 1 and may or may not believe fiction 2), DateTime
(which is agnostic about fiction 3), and "Localtime" and "Date" (which
believe fictions 3 and 4).
For each of these you have corresponding variants of Duration.
So my question is, which of these fict
means in the context of "Instant coffee". I think I still
> slightly prefer "instant", but I don't mind much any more :).
Ah, we want a noun that isn't readily confused as an adjective.
Suitable terms might include: Instant Jiffy Juncture Moment Occasion Snap Tick
...
-Martin
core though, just the low-level code that receives signals and arranges
not to leave a (broken) partially-formed call frame in the chain while
setting up a call frame to invoke the handler function.
-Martin
t; test, whereas "any(-x,+x)" would mostly be useful for
expressing solutions to polynomials.
Perhaps we could define infix:± as a range generator and prefix:± as a
set generator:
$y + ±5 # same as ($y - 5) | ($y + 5) (also same as $y - ±5)
$y ± 5# same as ($y - 5) .. ($y + 5)
-Martin
cutive
ranges will match; back to the original question, I'd only expect one match
from:
$time ~~ $date-yesterday
$time ~~ $date-today
$time ~~ $date-tomorrow
even if $time falls precisely on midnight.
-Martin
to each array-type?
role OffsetArray[::ElementType = Object;; int $MinIndex = 1]
{
is Array;
has ElementType @.contents;
method circumflex:? [ ] ? (int $index where { $_ >= $MinIndex } ) {
return @.contents[$index - $MinIndex];
}
}
-Martin
istently using lower half-open ranges.)
-Martin
On Thu, 26 Feb 2009, Martin D Kealey wrote:
> On Wed, 25 Feb 2009, Timothy S. Nelson wrote:
> > I'm in favour of retaining the $[ functionality, but lets give it some
> > name like $*INDEX_BEGINNING or something like that, so that it's quite
> > long for pe
" call will
always fail (having delayed until all child processes have exited),
whereas if you leave it as "default", your process will still ignore it,
but "wait" will work properly.
On some implementations SIGUSR1 and/or SIGUSR2 are ignored by default.
Core dumps are subject to ulimit controls, even when the signal in question
would normally trigger them.
-Martin
r" and "map"
@list = @array.map(&code);
&iterator = &code.for($signature);
@list = iterator(@list);
But I suspect they should logically be the other way around:
&iterator = &code.map($signature);
@list = iterator(@list);
@list = @array.for(&code);
-Martin
$x < $x and die;
# must not happen (same eigenstate must
# be used on both sides of '<' ?)
$x < $x.eigenstates.any() or die;
# matches for "-1 < +1"
-Martin
side
that, they are collections of indeterminate state. Indeterminate states
aren't sufficiently "value-like" to justify "constant folding".
-Martin
)
infix:«!==»(Object,Object) does(junctive_inversion)
(Excuse the rather lose syntax, but I hope you get the idea.)
-Martin
t the optimizer.
To that end I would propose that:
- parameters should be read-only AND invariant by default, and
- that invariance should be enforced passing a deep immutable clone
(*5) in place of any object that isn't already immutable.
-Martin
Footnotes:
*1: There are many possible reas
On Fri, 19 Jun 2009, Martin D Kealey wrote:
> To that end I would propose that:
> - parameters should be read-only AND invariant by default, and
> - that invariance should be enforced passing a deep immutable clone
>(*5) in place of any object that isn't already immutable.
t exception
should be propagated, and the other operand doesn't need to be evaluated.
If one operand is true then return it; otherwise return the right-hand
operand (which should be false).
This solves both the human expectation ("Would you like wine or beer or
juice?" "Beer a
On Thu, 2 Jul 2009, TSa wrote:
> Martin D Kealey wrote:
> > This solves both the human expectation ("Would you like wine or beer or
> > juice?" "Beer and juice please" "Sorry...") and the associativity
> > problem: (a ^^ b) ^^ (c ^^ d) == a
Cwd :chdir;
$*CWD = q; # OK, same as {chdir "/tmp"}
I wonder if this is becoming the new Perl mantra "use lexically scoped
pragmata".
perl6 -MCwd=fake ... # legacy behaviour
-Martin
be to use proxy objects, which only do
one of the roles (by passing them through to the appropriate methods on the
original object).
This could be done transparently to formal parameters, so that when they're
used locally they would dispatch the "expected" method based on the locally
declared type for the object.
-Martin
Some possible spellings include:
conj
⎺ high bar (reminiscent of the mathematical over-bar notation)
⌇ verticle squiggly line
⇅ up-and-down arrow (since it inverts imaginary but not real
parts)
-Martin
g, but a field or ring
over Z(2)^n does have interesting behaviour that depends on n.
So I'm in favour of a "Boolean" role including things such as a vector of
bits.
I suggest "Predicate" as the name of the role which implements a single
true-or-false value (as distinct from a bit, which implements a 0-or-1
value).
-Martin
drant. If you have more than one quadrant, take
them in turns. Extends to 3D and higher in a logic fashion.
But totally useless as a "greater than/equal to/less than" comparison test.
-Martin
what tools are we going to
need to build such an ADT? Well, privacy, trust, ...
-Martin
Hmm, surely a power-set would be written as
Set(Set(X,Y,...))
or perhaps more mathematically as
2 ** Set(X,Y,...)
-Martin
not simply extend pattern-matching in a similar way to substr, making it
an L-value, so that one gets
$str ~ /[aeiou]+/ = "vowels($&)"
or
$str ~ /\d/ {hyper-symbol}= (0) x {size-of-LHS-array};
(hyper, however it's spelt, will have some way for the RHS to reference the
LHS
,$count,@insertions);
vs
@excised = @array . slice($position,$count);
@unexcised = @array . splice($position,$count,@insertions);
So, in
@a = @b .= grep {/foo/};
should @a be the elements that I contain "foo" or those that I?
-Martin
text
implies otherwise. But in many Pacific island cultures (*), if one offers
"kava or coffee" one would be expected to provide both if answered "yes".
-Martin
(* This from annecdotal memory of 20 years ago, so I don't vouch that it
still applies in any particular cu
tomatically get
> _[!] for that as well.
postfix vs infix ... mumble ... parsing nightmare ... mumble ...
> I think we could also allow
>
> @a [??] @b [::] @c
>
> But it's not clear whether we can parse
>
> @a = [undef][...]
What about
$a = $x lazy:? $y : $z
so that $a is thus an object which when stringified (or numified or
whatever) chooses whether it's $y or $z, but not until?
-Martin
0"
> However, I think readability suffers without a hint on the front what
> you're trying to do.
We don't in general have a "let" on the front of assignment statements; why
should this type of assignment be any different? (Do we want a "let" keyword?
Personally I don't think so, but what do others think?)
-Martin
--
How to build a Caspian Sea oil pipeline - step one: get elected president...
achine... now I know
that's not entirely realistic, but it should be able to run at least say
60 times faster.
It's not that we necessarily want *preemptive* threads, but if we can't
do that, we certainly can't do multiprocessor threads.
-Martin
eral) be more closely controlled... and of
course the former can be used to implement the latter:
use visible '$topic';
no visible '$_';
-Martin
On Thu, 2002-11-21 at 06:57, Mark Biggar wrote:
> Martin D Kealey wrote:
> > I want Perl to run 128 times faster on a 128 CPU machine... now I know
> > that's not entirely realistic, but it should be able to run at least say
> > 60 times faster.
>
> Amdahl&#x
- that would be pointless as well as error-prone.
My idea of "visible" is that it would make a lexically scoped thing
accessible to an inner dynamic scope at run-time.
By default that would only apply to $_, but the mechanism should be
generalisable to any name.
-Martin
nd magical
references) right from the start of P6, just so as we don't break things by
making them so later.
-Martin
--
Help Microsoft stamp out software piracy: give Linux to a friend today...
The relationship to the array/list thing is this: that it's not just
pass-by-value to functions and methods, it's about implicit R-valueness in
any context that doesn't absolutely require L-valueness.
All this is orthogonal to the concept of "object": in C++ "an object" can be
used to implement either a value (such as "string") or a container (such as
"vector"); it would be nice to be able to do this in P6 too.
-Martin
PS: sorry for the long post...
, unthrown
exception) unless the user tells us how they want it treated. That can be a
command-line switch if necessary.
To paraphrase Dante, "the road to hell is paved with Reasonable Defaults".
Or in programming terms, your reasonable default is the cause of my ugly
work-around.
-Martin
{...}
when= VALUE-TO-MATCH {...} # implicit last
when? BOOLEAN-EXPRESSION {...}
when~ VALUE-TO-SMARTMATCH {...}
and then make bald "if" and "when" be DWIMmy shorthand.
Oh, and then "A ~~ B" just works like "?! (A) xor B", if B is a Bool.
-M
on over an arbitrary
function (to produce a boolean that can be used for flow control) starts to
sound fishy: how do we decide whether a given function should be treated
like "==", where the distributive rule produces the same junction type, or
like "!=", where the distributive rule produces the inverse junction type?
Or do we not invert junctions, and run the risk of unexpected
action-at-a-distance instead?
-Martin
ecombined; the result often won't be what's expected.
Don't get me wrong, I think Junctions are a really clever way of writing
concise conditional expressions, but I think algebraic consistency is
more important than clever conciseness.
-Martin
ful, for uncovering bugs,
including sometimes latent ones in ported code.
Duration is a fairly clear example of a dimensioned quantity, and I think we
should think twice about abandoning its dimensionality, and the
restrictions that implies.
-Martin
eating a "r/w" param as a
shorthand for both an r/o param AND an r/o return? So in effect, changes to
the "container" don't take effect until after the sub returns. (BTW this
would have a lot of benefits for auto-threading code.)
-Martin
t; or
«».
5. And pretty please could we have infix:<%>(Str,Capture) as an alias for
sprintf? (Not that I'm normally a Python fan, but that feature has a
particularly wholesome appeal about it.)
-Martin
On Sun, 25 Sep 2011, nore...@github.com wrote:
> Date: Sun, 25 Sep 2011 17:33:2
.
One could revert to the Perl5 and C++ way of doing things: explicitly
calling up the constructor chain. But then how do you make it clear that
BUILDALL is NOT required?
Is there an answer to this conundrum?
-Martin
s an
IteratorOf{X} and the RHS is an {X}, for X in {Int, Rat, Num} and possibly
other comparable (orderable) types, when ">" would be implied.
Likewise for AscendingArithmeticIteratorExclusiveTerminalSmartMatch (">=")
DescendingArithmeticIteratorInclusiveTerminalSmartMatch ("<") and
DescendingArithmeticIteratorExclusiveTerminalSmartMatch ("<=").
-Martin
t as part of any future test.)
But in that case, we should be saying up front that the test might change.
-Martin
Hmmm, what about just implementing mmap-as-string?
Then, assuming the parsing process is somewhat stream-like, the OS will take
care of swapping in chunks as you need them. You don't even need anything
special to support backtracking -- it's just a memory address, after all.
-Martin
differing
associativity?
Which then would mean that R would have to tweak the precedence slightly, to
avoid an implicit infraction.
So perhaps we could have a rule that meta-ops generate new operators of
marginally looser precedence than the originals?
-Martin
On Sun, 29 Mar 2015, GitHub wrote
ust likewise be a "value".
The hard bits include:
- getting the programmer to go to the trouble (making the writing of value
classes easier for the programmer than writing container classes);
- extracting and wrapping "values" from "container" classes, if the container
obje
rresponding reverse -- either it
recursively clones an object with container semantics changing the type of each
member to a constant value type, or it simply extracts the reference member.
Either way, calling .VALUE() on a value object simply returns SELF.
Option (a) is really only useful if
> If a routine is rw, you may optionally define a single "slurpy scalar"
> (e.g., '*$value') in its signature.
A good start, but why limit the Lvalue to a scalar? A list l-value seems like a
pretty us
t, $src, $limit) {
@r = split($pat, $src);
return @r[0..$limit-2], join($pat, @r[$limit-1..*]);
}
except of course it works where $pat isn't a string literal, and does sensible
things if $limit is 0 or 1, and is implemented more efficiently.
-Martin
> -Origi
70 matches
Mail list logo
