00:15:34 -!- peterecus has joined.
00:16:03 <peterecus> hello
00:16:41 <marshmallows> Hi
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:27 <marshmallows> I'll make a cup of a tea :P
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:16:58 <marshmallows> adu: #scheme ?
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:06 <marshmallows> PARSEC!!!
05:18:09 <adu> :)
05:18:12 <marshmallows> Woooo oooo
05:18:16 <marshmallows> I love parsec o_o
05:18:34 <marshmallows> so uh..
05:18:34 <adu> =)
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:11 <marshmallows> J:.@P7L1ke!
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:34 <marshmallows> language Java {
05:20:46 <marshmallows>   Is.Pretty.Structured();
05:20:47 <marshmallows> }
05:20:53 <adu> and in Haskell (x) always means "sections" but 'x' could mean move x forward before evaluation
05:21:18 <marshmallows> ++++++<+++->>>[+>++--.-.<>>>]<>++,+.
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:22:36 <marshmallows> lol
05:23:18 <marshmallows> sub perl { and $php; have =~ s/good/quoting/; facilities() };
05:23:49 <marshmallows> what other syntax is there
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:24 <marshmallows> show me the syntax!
05:25:32 <adu> well its multi-line
05:25:37 <adu> [1 0 0
05:25:39 <adu>  0 1 0
05:25:49 <adu>  0 0 1 ;; 1 0 0
05:25:57 <adu>          0 1 0
05:26:03 <adu>          0 0 1]
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:03 <marshmallows> ok
05:27:05 <marshmallows> that's cool
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:17 <lament> adu: disciple = ddc?
05:29:20 <adu> yes
05:29:24 <lament> how do you like it?
05:29:34 <adu> never used it, only been reading the wiki
05:29:39 <lament> oh
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:30:54 <lament> !!!
05:31:03 <adu> hehehe
05:31:37 <adu> lament: are you related to DDC?
05:31:40 <lament> no
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:03 <adu> lol
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:36:18 <marshmallows> :O
05:36:19 <marshmallows> SYNTAX
05:36:23 <adu> hehehe
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:33 <marshmallows> what are these primitives?
05:38:56 <lament> let(, let[, let{, lambda and define
05:39:01 <adu> (.) (:) () [] {}
05:39:10 <adu> thats all
05:39:14 <lament> ha, almost
05:39:14 <adu> everything else is a function
05:39:15 <marshmallows> omg :D
05:39:17 <marshmallows> this is awesome
05:39:38 <marshmallows> have you implemented it?
05:39:42 <adu> partially
05:40:05 <marshmallows> what do they all do?
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:02 <marshmallows> ah cool
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:10 <lament> so.......
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:32 <marshmallows> It wouldn't be a problem
05:45:50 <adu> I'm aware of typeable
05:45:55 <marshmallows> no no
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 <marshmallows> typeable is gross
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:50:46 <adu> hehehe
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:49 <adu> later
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.
12:59:55 <oklofok> asiekierka: all can
13:00:05 <oklofok> *most can
13:05:45 <asiekierka> ... what's the best one for it though
13:09:14 <asiekierka> what about an esoteric language "Penper"?
13:09:17 <asiekierka> Paper esoteric language
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:11 <asiekierka> You can't clear it though.
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:57:28 <oklofok> k
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:46 <SimonRC_> oklofok: or immutable tables
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:26 <oklofok> sure
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:12 <oklofok> i know prolog, somewhat
21:29:21 <vixey> basically
21:29:33 <vixey> Curry seems no better than Prolog with Haskell syntax
21:29:46 <oklofok> heh
21:29:56 <oklofok> they say it's almost a superset of haskell though.
21:30:47 <lament> wow, looks ugly :)
21:31:23 <oklofok> i found it pretty
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.
22:44:41 * AnMaster got a cold :(
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).