00:15:34 -!- peterecus has joined.
00:17:33 -!- peterecus has quit (Client Quit).
01:38:36 -!- timotiis_ has quit ("leaving").
01:44:19 -!- Slereah has quit (Read error: 104 (Connection reset by peer)).
01:46:16 -!- Slereah has joined.
01:50:07 -!- sebbu has quit ("@+").
02:40:31 -!- jix has quit ("CommandQ").
03:06:29 -!- GreaseMonkey has joined.
04:58:35 -!- Corun has quit ("WWDC HO!").
05:07:27 -!- adu has joined.
05:15:35 <marshmallows> What's EVERY syntax of EVERY programming language?
05:16:16 <adu> marshmallows: well, that's gonna take some time to compile
05:16:31 <adu> marshmallows: hey, I remember you from some other channel...
05:16:52 <marshmallows> hm I hope I wasn't doing anything out of order
05:17:53 <adu> marshmallows: most of it can be summarized by (PreOp X)|(X InOp Y)|(Y PostOp)|(between LeftThing RightThing X)|(sepBy X Sep)
05:18:49 <marshmallows> (s-expression (syntax (lets you) nest things))
05:19:12 <adu> thats all handled by (between '(' ')' SExp)
05:19:18 <marshmallows> haskell = Pretty `good` (too ++ infix is) neat
05:19:31 <adu> I had an idea about infix and forth recently
05:19:39 <marshmallows> prolog(Has) :- very_uniform(Syntax), as(Well).
05:20:12 <adu> well, I was thinking about Haskells `x` syntax, and I had noticed that the back-quotes effectively transformed what was inside of it to move backwards before evaluation
05:20:53 <adu> and in Haskell (x) always means "sections" but 'x' could mean move x forward before evaluation
05:21:24 <adu> so you could do things like ('+' 4 5) == 4 5 `+`
05:21:32 <adu> to simulate forth and lisp at the same time!
05:21:59 <adu> my favorite APL/J/K like language is Funge-98
05:22:24 <adu> I have the Funge98 spec as my browser's homepage :)
05:22:28 <adu> it never gets old...
05:23:18 <marshmallows> sub perl { and $php; have =~ s/good/quoting/; facilities() };
05:24:01 <adu> My 2 favorite new-languages, right now, are Disciple and Fortress
05:24:48 <adu> although I only like them because Disciple is the only language I know with an explicit Effect system, and Fortress has the most amazing Array syntax
05:25:23 <adu> I'm actually thinking about implementing a new operator in Parsec for it, called "repBy"
05:25:32 <adu> well its multi-line
05:25:49 <adu> 0 0 1 ;; 1 0 0
05:26:14 <adu> would be a 3*3*2 array
05:26:53 <adu> which can also be written [1 0 0;0 1 0;0 0 1;;1 0 0;0 1 0;0 0 1]
05:26:58 <adu> or [[1 0 0;0 1 0;0 0 1] [1 0 0;0 1 0;0 0 1]]
05:27:22 <adu> or [[[1 0 0] [0 1 0] [0 0 1] [1 0 0] [0 1 0] [0 0 1]]
05:27:38 <adu> they are all equivalent in Fortress
05:28:19 <adu> the ";" is repeated in order to get higher-dimentional separation
05:28:45 <adu> so I'm trying to figure out how to implement that in a Parsec-like "repBy" combionator
05:29:34 <adu> never used it, only been reading the wiki
05:29:44 <adu> but so far I like it
05:30:08 <adu> although a friend of mine things there's too many "!" marks
05:31:37 <adu> lament: are you related to DDC?
05:31:55 <adu> lament: how do you like it?
05:32:04 <lament> never used it, only been reading the wiki
05:32:10 <adu> heh, like me
05:32:55 <lament> exactly! omg we're like soulmates rofl!!! asl?
05:33:35 <adu> I'm old, comfortable with my sexuality, and here.
05:34:21 <adu> but anyways, have I talked about my language yet
05:34:57 <adu> I have a plan for removing the cruft of some other languages
05:35:36 <lament> okay, start from perl, cobol and c++, come back when you removed cruft from those :)
05:36:03 <adu> for example, let, let* and letrec in scheme, in my language would be "let (x=y) {...}", "let [x=y] {...}", and "let {x=y} {...}" respectively, none of that "*" business
05:37:03 <adu> my language would be very schemish, and very haskellish too
05:37:13 <lament> adu: how about just replacing all those things with a single statement "let"?
05:37:18 <adu> all built up from 5 primitives
05:37:20 <lament> i mean, who really needs separate let and letrec?
05:37:51 <adu> well, i dunno
05:38:56 <lament> let(, let[, let{, lambda and define
05:39:01 <adu> (.) (:) () [] {}
05:39:14 <adu> everything else is a function
05:40:17 <adu> I've implemented a parser and a piece of the interpreter in Python + Ply, but I'm planning on re-writing it in Haskell + Parsec
05:40:48 <lament> if you have those things as primitives, do you actually need let?
05:41:00 <lament> i suppose they fuck with environments in some way?
05:41:05 <adu> (.) is homogeneous cons (:) is heterogeneous cons, (which correspond to [1, 2, 3] and [1; "Hello"; True] type lists respectively)
05:41:40 <adu> and () [] and {} are just wraps that keep their info, and pass the syntax tree inside of them to functions called "Tuple" "List" and "Set"
05:42:04 <adu> and the plan is the have these 3 functions add some kind of methods, but I don't really want them to be builtin
05:43:14 <adu> so [1, 2, 3] is syntax for 1 . 2 . 3 . []
05:43:24 <adu> just as {1, 2, 3} is syntax for 1 . 2 . 3 . {}
05:43:54 <adu> very lispish
05:44:13 <lament> why not just use haskell? :)
05:44:24 <adu> because Haskell doesn't have native heterogeneous lists
05:44:35 <lament> sure it does, see Typable
05:44:51 <adu> but I am using it to build the next version of the interpreter
05:45:50 <adu> I'm aware of typeable
05:45:57 <adu> there are other reasons
05:46:08 <lament> besides, what do you actually want heterogenous lists for?
05:46:15 <marshmallows> data Value = VInt Integer | VString String | VTuple Value Value ...
05:46:23 <adu> lament: do statements
05:47:06 <adu> begin expressions, progn expressions, etc
05:47:39 <adu> these are all things constructed with a heterogeneous cons-like operator
05:47:48 <adu> in Haskell this turns out to be (>>=)
05:49:02 <adu> so the "..." in "let {x=y} {...; ...}" would probably have ";" because its probably doing things
05:49:27 <lament> yes, except >>= is not heterogenous
05:50:11 <adu> lament: how so?
05:50:36 <lament> for one, haskell has it, and you just said haskell didn't have heterogenous lists :)
05:51:00 <lament> for two, it has a type m a -> (a -> m b) -> m b
05:52:17 <adu> it is a little stricter than heterogeneous lists
06:02:58 <adu> I should sleep
06:03:02 <lament> it's not any different from a -> [a] -> [a]
06:03:13 <lament> the types of the first and the second argument are different
06:10:35 <adu> (:) :: a -> m b -> m c
06:10:49 <adu> so really, (:) = flip (>>=)
06:21:38 -!- adu has quit (Remote closed the connection).
06:53:00 -!- RodgerTheGreat has quit.
07:30:40 -!- AnMaster_ has joined.
07:44:01 -!- AnMaster has quit (Success).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:09:58 -!- immibis has joined.
08:33:41 -!- immibis has quit ("Hi Im a qit msg virus. Pls rplce ur old qit msg wit tis 1 & hlp me tk ovr th wrld of IRC. and dlte ur files. and email ths to).
09:14:51 -!- sebbu has joined.
09:27:22 -!- GreaseMonkey has quit ("Read error: 110 (Connection chickened out)").
12:34:18 -!- asiekierka has joined.
12:34:31 <asiekierka> Is there an esoteric language that can be used with just paper and pencil?
12:42:03 -!- timotiis has joined.
13:09:14 <asiekierka> what about an esoteric language "Penper"?
13:10:07 <asiekierka> I thought of memory consisting of ~500 dots on paper. If you set it, you draw a circle around it.
13:10:21 <asiekierka> So I assume you have an infinite supply of paper.
13:16:35 <asiekierka> You know, i think Piet is the best one
13:20:05 -!- puzzlet has quit (Remote closed the connection).
13:20:13 -!- puzzlet has joined.
13:30:17 -!- jix has joined.
13:57:13 <oklofok> well you want to have a language where memory isn't really erased that much
13:57:28 <oklofok> so perhaps a cyclig tag system might do the tric
13:58:02 <oklofok> queues are pretty much the only data structure paper handles without complaining
14:38:41 -!- AnMaster_ has changed nick to AnMaster.
15:51:50 -!- SimonRC_ has changed nick to SimonRC.
16:45:39 -!- marshmallows has quit (Nick collision from services.).
17:07:14 -!- asiekierka has quit (Read error: 110 (Connection timed out)).
18:21:52 -!- RodgerTheGreat has joined.
18:25:12 -!- Slereah has quit (Read error: 104 (Connection reset by peer)).
18:25:17 -!- Slereah has joined.
18:29:27 -!- slereah_ has joined.
18:30:15 -!- Slereah has quit (Read error: 104 (Connection reset by peer)).
18:39:02 -!- slereah__ has joined.
18:39:59 -!- slereah_ has quit (Read error: 104 (Connection reset by peer)).
18:46:11 -!- slereah__ has quit (Remote closed the connection).
18:46:26 -!- slereah__ has joined.
19:05:20 -!- olsner has joined.
19:06:01 -!- slereah_ has joined.
19:07:14 -!- slereah__ has quit (Read error: 104 (Connection reset by peer)).
19:11:37 -!- slereah__ has joined.
19:25:13 -!- slereah_ has quit (Read error: 110 (Connection timed out)).
20:05:24 -!- oerjan has joined.
20:13:52 -!- timotiis_ has joined.
20:26:46 -!- timotiis has quit (Read error: 110 (Connection timed out)).
21:06:02 -!- vixey has joined.
21:19:00 -!- oerjan has quit ("leaving").
21:26:54 <vixey> oklofok : wanna see a Curry example?
21:28:47 <vixey> you know Prolog right?
21:28:50 <GregorR> Mmmmmmmmmm, I'd love to see an example of Curry. And eat it.
21:28:54 <oklofok> although i find the spontaneous change of channel confusing
21:29:06 <vixey> http://rafb.net/p/jZJ8fv54.txt
21:29:33 <vixey> Curry seems no better than Prolog with Haskell syntax
21:29:56 <oklofok> they say it's almost a superset of haskell though.
21:32:02 <vixey> well the problem is saturn2 is not efficient
21:33:37 <vixey> I want to see what's good about it but I don't :|
21:47:10 -!- Judofyr has joined.
23:17:29 -!- Judofyr has quit (Read error: 104 (Connection reset by peer)).
23:18:36 -!- Judofyr has joined.
23:37:42 -!- jix has quit (Nick collision from services.).
23:37:52 -!- jix has joined.
23:47:33 -!- Judofyr has quit (Read error: 104 (Connection reset by peer)).
23:47:46 -!- Judofyr has joined.
23:55:35 -!- MommeMC has joined.
23:55:46 -!- MommeMC has quit (Client Quit).