Comments on nothingmuch's perl blog: Abstracting Ambiguity

You might find this old post of mine about doing s...

2009-09-06T03:15:01.871+03:00

You might find this old post of mine about doing some continuation based declarative coding in Perl of mild interest

http://www.perlmonks.org/?node_id=193649

it's a nice model for those times I miss Prolog :-)

I can't wait to play with this! I found a similar...

2009-08-27T03:12:40.811+03:00

I can't wait to play with this!

I found a similar backtracking example in scheme a while back and ported it to Ruby (1.8):

http://pastie.org/596143

I wrote a perl version as well using Coro::State, but it's untested because I never got round to configuring support for the continuation "game" (as Marc Lehmann calls it) in Coro (it uses the callcc implementation from the POD):

http://pastie.org/596157

I was thinking of a related acme module, basically...

2009-08-25T12:52:31.440+03:00

I was thinking of a related acme module, basically an object that overloads all operators to do predicate unification and when it's resolved into an actual value (e.g. '""' or '+0' overloading) that invokes amb as a thunk, and returns some value that satisfies the constraints.

Comparators in void context become assertions:

$x == $y; # this is true

and we get instant prolog.

The problem is that I have no idea how to capture continuations with actual C stack frames (i don't think that's even possible in a portable way), so that kills overloading.

You could use this for solving problems like this:...

2009-08-25T07:48:42.708+03:00

You could use this for solving problems like this:

send + more = money

for my $l (split "", "sendmorny") {
$l{$l} = amb(0..9);
$$l = $l{$l};
}
# must be unique
my %vals = map { $_ => 1 } values %l;
amb_assert(keys(%vals) == keys(%l));

# run off the expression
my $cry;
amb_assert(($cry=$d + $e)%10 == $y);
$cry = ($cry > 9 ? 1 : 0);
amb_assert(($cry=$n + $r + $cry)%10 == $e);
$cry = ($cry > 9 ? 1 : 0);
amb_assert(($cry=$e + $o + $cry)%10 == $n);
$cry = ($cry > 9 ? 1 : 0);
amb_assert(($cry=$s + $m + $cry)%10 == $o);
$cry = ($cry > 9 ? 1 : 0);
amb_assert($cry == $m);

$string = "$s$e$n$d + $m$o$r$e == $m$o$n$e$y";
amb_assert(eval $string);
print "$string\n";

see also my experiments with Junctions from 2005

You can do that in Haskell because every expressio...

2009-08-24T14:09:34.425+03:00

You can do that in Haskell because every expression in a do block is an implicit lambda and you can control the way they are sequenced based on the typeclass of the data involved.

Since mbind is effectively the increment-the-instruction-pointer operation for any data that is relevant or interesting, they are a more generic abstraction than continuations.

Unsurprisingly, continuations in Haskell are implemented in terms of a monad (which also makes the implementation very clean and simple, since mbind is already effectively CPS and there's no mutable data).

In Perl 6 this could theoretically still be done (e.g. by rewriting the AST) but in Perl 5 I am not sure there is a way to do this without suffering brain damage.

B::Generate is not stable enough and there are no APIs for compiling new lexical pad structures and assigning indices, it would be a massive effort (but if done the results would be awesome).

I guess by walking the optree and annotating some sort of ANF representation (op_next is pretty much ANF if you squint right) you could generate a minimal syntactic unit for new symbol introduction and convert all expressions into implicit subroutines, and then reparse that, but I think that'll end up being pretty brittle.

Anyway, if anyone has read this far, real monads are the next step ;-)

Or you can overload control flow and data at the s...

2009-08-24T13:59:05.695+03:00

Or you can overload control flow and data at the same time...

do {
x <- [1,2,3];
y <- [1,2,3];
guard (x > 2);
guard (x + y == 5);
guard (y <= 2);
return (show x ++ " + " ++ show y ++ " = 5")
}

A major contributor to my stifled inspiration for Perl 6 was realizing how much Junctions wanted to be Monad []. But it was no fault of the Junctions: it was their society keeping them from realizing their true potential.

In case you didn't see this: http://search.cpan.or...

2009-08-24T11:35:08.223+03:00

In case you didn't see this: http://search.cpan.org/dist/Amb/