< 1261785741 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :movement :o
< 1261785873 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :afk dessert :X
< 1261786045 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :see you
< 1261786485 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :o hai
< 1261786602 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :o hai?
< 1261786618 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :oh, hi
< 1261786724 0 :bsmntbombdood_!n=gavin@97-124-201-100.hlrn.qwest.net JOIN :#esoteric
< 1261786731 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :əʊ haɪ?
< 1261786803 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :youre canadian arent you
< 1261786847 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :New York born and raised
< 1261786864 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :huh. then your ling training was better than i expected. or something.
< 1261786881 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :tho i indeed wouldve said @U, i probably wouldve transcribed it as oU
< 1261786999 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :more like copying and pasting from the local IPA-friendly dictionary
< 1261787015 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :I can read IPA. (hardly)
< 1261787050 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :I can speak LaTeX, though. got my IDE to be ∈ the mode for ∞ LaTeX enjoyment
< 1261787078 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :latex made me reveal my password to irc the other day :|
< 1261787085 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i'd been doing my semantics homework in latex
< 1261787093 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :lots of \f{x} shit all day
< 1261787095 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :for like two days
< 1261787105 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :then i go to irc and notice im nicked as augur_
< 1261787108 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so i type in
< 1261787118 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :\msg nickserv id flibble
< 1261787122 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :in a channel
< 1261787123 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :...
< 1261787145 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :cute password. *blows a kiss to it*
< 1261787151 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :oh, yeah. backslash is not natural.
< 1261787156 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :NOT NATURAL MAN
< 1261787157 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, thats not what it was, right
< 1261787163 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i just chose it as an example
< 1261787164 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::P
< 1261787182 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :well, well, my fake password is bubbles. and it's cuter than yours! >:|
< 1261787190 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::P
< 1261787198 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but mine is MISTER flibble! :|
< 1261787269 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :oh god, looks like I'm dealing with a professional here. *backs away slowly*
< 1261787330 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :ACTION browses reddit
< 1261787434 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :I'm watching Buffy. yes, THE VAMPIRE SLAYER
< 1261787439 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :D:
< 1261787455 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :it is keeping me quite interested
< 1261787853 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ok so heres my idea
< 1261787865 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you'd have the expression 1 + 2
< 1261787872 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"1 + 2"
< 1261787890 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :with the "abstract" structure ["1", ["+", "2"]]
< 1261787947 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"1" = 1 :: n, "2" = 2 :: n, "+" = \s:SUM(s) -> true :: s -> t / n,n,n
< 1261787978 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :where n,n,n means "if s is SUM(s) then you need three more participants to evaluate this expression"
< 1261788020 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :["+", "2"] = \s:SUM(s) -> true && first(s,2) :: s -> t / n,n
< 1261788048 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :["1", ["+", "2"]] = \s:SUM(s) -> true && first(s,2) && second(s,1) :: s -> t / n
< 1261788064 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the evaluator says, ok this is the top of the tree
< 1261788066 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so we lift it now:
< 1261788084 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :\s:SUM(s) -> true && first(s,2) && second(s,1) && third(s,w) :: s -> t
< 1261788099 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but this isnt a value type so close over it
< 1261788108 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Es:SUM(s)[true && first(s,2) && second(s,1) && third(s,w)]
< 1261788117 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but this has an open variable, so question-close that
< 1261788126 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Ws[Es:SUM(s)[true && first(s,2) && second(s,1) && third(s,w)]]
< 1261788142 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and this can be evaluated because this is a structure that the evaluator understands
< 1261788148 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :namely, it means 1+2
< 1261788159 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so it evaluates it Ww[Es:SUM(s)[true && first(s,2) && second(s,1) && third(s,w)]] and returns 3
< 1261788187 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :(well, first it does some logic to conjunction reduce Ww[Es:SUM(s)[true && first(s,2) && second(s,1) && third(s,w)]] to Ww[Es:SUM(s)[first(s,2) && second(s,1) && third(s,w)]]
< 1261788188 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::p
< 1261788360 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :ACTION makes a note to take semantics
< 1261788367 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :"Seriously messes with your mind"
< 1261788372 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::p
< 1261788434 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :tell me about semantics
< 1261788737 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :why, back in my day, the whole family came to together to talk about semantics in front of the fireplace, we exchanged many arguments about.. er.. whatever semantics is about.. and lambdas.. ∀ dog. ∃ person and stuff
< 1261788747 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :o_o
< 1261788760 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::P
< 1261788972 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :motherfucking damn
< 1261788978 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :i've got a couple of sticky pixels
< 1261789027 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ok ive refined the ideas some more
< 1261789055 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :brb
< 1261789107 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ok
< 1261789108 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so
< 1261789123 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :imagine you have the expression "a one + a two"
< 1261789143 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :for simplicity actually, lets say just "1 plus a two" instead
< 1261789171 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :lets say "1" ~ 1 :: n
< 1261789195 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"plus" ~ \s:SUM(s).true :: s -> t / n,n,n
< 1261789207 0 :calamari!n=calamari@ip72-211-145-161.tc.ph.cox.net JOIN :#esoteric
< 1261789219 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"two" ~ \y.y = 2 :: n -> t
< 1261789243 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and "a" ~ \p.Ey.p(y) :: (n -> t) -> t
< 1261789287 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or even, lets say, "a" ~ \p.\q.Ey.p(y) & q(y) :: (n -> t) -> (n -> t) -> t
< 1261789302 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Gracenotes: semantics messes with your mind?
< 1261789316 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :(uorygl: look at what im saying! its messed with MY mind! :D)
< 1261789361 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you put together "a" with "two" to get
< 1261789388 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :It would be nice if I knew what you were talking about.
< 1261789389 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :\q.Ey[y = 2 & q(y)] :: (n -> t) -> t
< 1261789401 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :And what your notation is.
< 1261789427 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :then you TRY to put together \s:SUM(s).true :: s -> t / n,n,n with \q.Ey[y = 2 & q(y)] :: (n -> t) -> t
< 1261789430 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but this fails
< 1261789436 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :then you notice, hold on
< 1261789464 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :(n -> t) -> t?! maybe if i replace the expression "a two" with some unbound variable z :: n
< 1261789477 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :So, um, "1 plus a two".
< 1261789553 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :eh no sorry my explanations are sucky :d
< 1261789554 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::D
< 1261789562 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :my logic isnt quite worked out yet
< 1261789585 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :1 is a DP; it denotes a specific value.
< 1261789592 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Two is a noun; it denotes a type of thing.
< 1261789613 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :A is a determiner; it takes a type of thing and denotes a specific instance of it.
< 1261789621 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :actually, DP's dont denote specific values
< 1261789622 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Though it doesn't specify the specific instance. :-P
< 1261789623 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but nevermind
< 1261789634 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :DPs totally denote specific values!
< 1261789654 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :actually they dont
< 1261789659 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but thats ok
< 1261789706 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Plus is... a conjunction? A preposition? Anyway, it takes two DPs and becomes a DP denoting their sum.
< 1261789728 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :plus is a lambda with a body, and a restriction on its variables
< 1261789740 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"plus a two" i is another lambda
< 1261789743 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ok i think i have it
< 1261789759 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Well, figure out whether "plus" is a conjunction or a preposition.
< 1261789772 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I guess maybe it's both.
< 1261789817 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :So, DPs don't denote specific values?
< 1261789837 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Explain.
< 1261789837 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"a two" then has the value \q.Ey[y = 2 & q(y)] :: (n -> t) -> t
< 1261789851 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so you notice, ok fuck, this doesnt combine with "plus" :: s -> t / n,n,n
< 1261789867 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but then you notice, hey, "plus" needs an n participant, and i'm an (n -> t) -> t
< 1261789890 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so lets replace "a plus" with an unbound z, and hold "a plus" off on the side for a while
< 1261789896 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Hang on.
< 1261789903 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :(n -> t) -> t is the same as C n for some monad C.
< 1261789907 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :hush
< 1261789915 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Go on.
< 1261789917 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so we instead pretend this is "plus z" where z :: n
< 1261789924 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :holding "a plus" on the side
< 1261789960 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so now we combine \s:SUM(s).true :: s -> t / n,n,n with z :: n, returning
< 1261789995 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :\s:SUM(s).(true && first(s,z)) :: s -> t / n,n
< 1261790011 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :then we combine 1 :: n with that, returning
< 1261790032 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :\s:SUM(s).(true && first(s,z) && second(s,1)) :: s -> t / n
< 1261790064 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :then we say, ok, so this is the top of the tree, but thats not a value i can deal with
< 1261790093 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so let me pull this up to an existentially closed statement
< 1261790103 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :er sorry, no
< 1261790104 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::p
< 1261790116 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :first, let me add the last n:
< 1261790129 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :\s:SUM(s).(true && first(s,z) && second(s,1) && third(s,w)) :: s -> t
< 1261790142 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so now i can existentially close s:
< 1261790155 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Es:SUM(s).(true && first(s,z) && second(s,1) && third(s,w)) :: t
< 1261790191 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but z is associated with "a two" and i havent handled that yet
< 1261790212 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so "a two" is \q.Ez[z = 2 && q(y)]
< 1261790226 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and we can bind z on the whole tree:
< 1261790234 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :\z.Es:SUM(s).(true && first(s,z) && second(s,1) && third(s,w)) :: n -> t
< 1261790240 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and hey, n -> t!
< 1261790246 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :this is what q needs to be!
< 1261790251 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so lets use this as the value for q
< 1261790264 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :combining "a plus" with "1 plus z"
< 1261790266 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :giving back
< 1261790282 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Ez[z = 2 && Es:SUM(s).(true && first(s,z) && second(s,1) && third(s,w))] :: t
< 1261790285 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :lovely
< 1261790304 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but w is open and we introduced it to satisfy the participant needs of s:SUM(s)
< 1261790318 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so we have to bind that with a question operator
< 1261790332 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Ww[Ez[z = 2 && Es:SUM(s).(true && first(s,z) && second(s,1) && third(s,w))]]
< 1261790336 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ok, lovely
< 1261790369 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but this isnt something we know how to complrehend, so lets do some logic: minimize Ez to exist around the smallest thing it can:
< 1261790389 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Ww[Es:SUM(s)[true && Ez[z = 2 && first(s,z)] && second(s,1) && third(s,w)]]]
< 1261790404 0 :soupdragon!unknown@unknown.invalid QUIT :"Leaving"
< 1261790409 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :now apply some general theorem that Ex[x = y && p(x)] :- p(y)
< 1261790410 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :to give
< 1261790431 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Ww[Es:SUM(s)[true && first(s,2) && second(s,1) && third(s,w)]]]
< 1261790436 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :then conjunction reduce true out of existence
< 1261790440 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Ww[Es:SUM(s)[first(s,2) && second(s,1) && third(s,w)]]]
< 1261790456 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and now notice that this is precisely the kind of statement that the interpreter understands by default.
< 1261790456 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::"D
< 1261791030 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :So, what's the purpose of all this?
< 1261791037 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Are we trying to make computers understand English?
< 1261791041 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no
< 1261791043 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :quite the opposite
< 1261791045 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its an esolang
< 1261791052 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Oh.
< 1261791055 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :designed to have syntacto-semantics like natural language
< 1261791079 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I guess I can see why in this sense DPs don't denote specific values.
< 1261791262 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :So in your language thing, a DP has type (n -> t) -> t?
< 1261791262 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :It's a predicate on predicates?
< 1261791262 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its not a DP
< 1261791262 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :What do you mean by "it"?
< 1261791262 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"a two" is just a convenient use of english words for function names
< 1261791262 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :In English, "a two" is a DP.
< 1261791262 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yes
< 1261791262 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but this isnt english!
< 1261791262 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :True.
< 1261791262 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"a two" is just a function of type (n -> t) -> t
< 1261791262 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :So by DP, I mean a thing that looks like an English DP.
< 1261791262 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :So why is it an (n -> t) -> t?
< 1261791262 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because i wanted to force QR
< 1261791262 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :If you're trying to be English-like, I would expect a DP to be either a value or a predicate on values.
< 1261791262 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Anyway, what's QR?
< 1261791262 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :quantifier raising
< 1261791262 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"a two" is actually a quantifier, right
< 1261791262 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :\q.Ex[x = 2 && q(x)]
< 1261791281 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :just like you might have some quantifier in haskell
< 1261791299 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or haskellish
< 1261791318 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Can you use pseudo-Haskell notation here? I'm not used to whatever you're using.
< 1261791318 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :all xs f = Ex:(x in xs)[f(x)]
< 1261791339 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or, for the sake of being pure
< 1261791349 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :lets define
< 1261791356 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well no we cant define
< 1261791357 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :haha
< 1261791360 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :were TRYING to define
< 1261791361 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::D
< 1261791362 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ok
< 1261791364 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I'm not following a lot of what you're saying.
< 1261791381 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :all xs f = foldr (&&) True (map f xs)
< 1261791426 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :exists xs f = foldr (||) False (map f xs)
< 1261791436 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :exists ~ some
< 1261791437 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :whatever
< 1261791448 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Did you tell me what the value of "a two" is?
< 1261791453 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :not yet
< 1261791455 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :im getting ther e:D
< 1261791459 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::D
< 1261791467 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I think I'd rather you just tell me and we work backwards.
< 1261791508 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :a f g = exists [x : x <- [1..], f x] g
< 1261791520 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :If I want to learn why the gostak distims what it does, I'd like to know what the gostak distims first.
< 1261791531 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :two x = x == 2
< 1261791545 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :a two == exists [x : x <- [1..], x == 2] g
< 1261791564 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :s/a two/a two g/, I'm assuming.
< 1261791571 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :er, yeah sure
< 1261791580 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :a two = exists [x : x <- [1..], x == 2]
< 1261791594 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :now we have plus
< 1261791616 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :So "a two" takes a predicate and returns whether 2 satisfies that predicate, right?
< 1261791623 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yep
< 1261791627 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :plus is something i cant write in haskell, but lets modify haskell a bit
< 1261791667 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :lets say that in haskell, the argument in a lambda can have a restriction which is _almost_ like a type but instead tells you what kind of thing this is for semantic interpretability
< 1261791671 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :we'll denote it like so
< 1261791676 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f x:R = ...
< 1261791681 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :where R is the restriction
< 1261791693 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so lets say that plus s:SUM = true
< 1261791700 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :So in your type system, n means values and t means Booleans, right?
< 1261791709 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :n means Ints, t means Bools
< 1261791713 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :s means States
< 1261791723 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so plus s:SUM = true :: s -> t
< 1261791726 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :That means a DP is C n, where C is the continuation monad C x = (x -> t) -> t.
< 1261791754 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but since s:SUM, and SUMs need 3 "participants" in order to be semantically _sensible_
< 1261791760 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :we can say
< 1261791769 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :plus s:SUM = true :: s -> t / 3
< 1261791783 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :"s:SUM" can be read "s which is a SUM", yes?
< 1261791790 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or s -> t / n,n,n specifically
< 1261791796 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :sure, s-which-is-a-SUM
< 1261791800 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but its not a type restriction, keep in mind
< 1261791803 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Right.
< 1261791821 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ok so now we want to combine "plus" with "a two"
< 1261791829 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :In "plus s:SUM = true :: s -> t / 3", are you using s consistently?
< 1261791835 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :It looks like you're using it inconsistently.
< 1261791847 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :What does "t / 3" mean?
< 1261791855 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its (s -> t) / 3
< 1261791864 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Oh.
< 1261791869 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the / 3 means "needs three participants in order to be sensible"
< 1261791885 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :im using s as both the name of the type and the name of the var
< 1261791890 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Don't do that.
< 1261791896 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if you want, plus s:SUM = true :: S -> T / N,N,N
< 1261791902 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Wonderful.
< 1261791903 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :anyway
< 1261791917 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and "a two" is (N -> T) -> T
< 1261791921 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so this doesnt match up
< 1261791924 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :It looks to me like you're being really complicated. :-P
< 1261791931 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"a two" cant be an arg to "plus"
< 1261791939 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so lets be hopeful:
< 1261791941 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :What is a State, anyway?
< 1261791945 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :dont worry ;P
< 1261791955 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :in the end, the primitive types wont matter
< 1261791962 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and we can make it untyped
< 1261791965 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or mono-typed
< 1261791974 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, mono-primitive
< 1261791979 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :anyway
< 1261791983 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so lets be hopeful
< 1261791987 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I would have plus :: ((N,N,N) -> T) -> T or something.
< 1261791993 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no shush
< 1261791994 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :listen
< 1261791996 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :be quite
< 1261791997 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Yes, sir.
< 1261792009 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :since "a two" looks like (a -> b) -> b
< 1261792018 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :this just looks like a type-lifted a
< 1261792023 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Right.
< 1261792025 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so "a two" looks like a type-lifted N
< 1261792038 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so lets replace "a two" with some place holder, call it tz
< 1261792039 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :of type N
< 1261792048 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and hold "a two" off to the side
< 1261792050 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Great.
< 1261792066 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so now what we're really trying to do is combine plus :: (S -> T) / N,N,N with tz :: N
< 1261792076 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, still, tz isnt an S so it cant be an argument to plus
< 1261792083 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but maybe its one of those three participants!
< 1261792089 0 :Pthing!unknown@unknown.invalid QUIT :Remote closed the connection
< 1261792100 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Do you want to explain why plus has that type?
< 1261792103 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no
< 1261792110 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its magic, youll see
< 1261792118 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so we can specify this. its the first of the three participants to be added, sooo
< 1261792122 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :we combine the two like so:
< 1261792162 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :plus ^ tz = \s:SUM -> true && first(s,z) :: S -> T / N,N
< 1261792195 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :pretend i said z everywhere before where i said tz :p
< 1261792211 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Sure...
< 1261792221 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :(im mixing domains of discourse here, so im thinking partially in terms of words with meanings, and partially in terms of pure meanings, so its difficult. anyway...)
< 1261792236 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so plus ^ tz = \s:SUM -> true && first(s,z) :: S -> T / N,N
< 1261792241 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Sure.
< 1261792257 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :now 1 is :: N
< 1261792262 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :cause remmber we're doing "1 plus a two"
< 1261792272 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :(As you can see, the ellipsis denoted that I was responding to your second to last message. :-P)
< 1261792272 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :N again can be used as a participant
< 1261792281 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::P
< 1261792317 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :You know, it seems to me that natural language has a value embed :: (Monad m) => m a -> a
< 1261792325 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so we combine (plus ^ z) with 1: 1 ^ (plus ^ z) = \s:SUM -> true && first(s,z) && second(s,1) :: S -> T / N
< 1261792351 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and now we've handled the whole of the _expression_ "1 plus z"
< 1261792353 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but wait
< 1261792358 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :we have some problems!
< 1261792369 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :first, we didnt handle that whole "a two" thing, we just left it off to the size
< 1261792390 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :second we still dont have a last N participant for this function
< 1261792395 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so we must proceed!
< 1261792397 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I don't think I can continue listening unless you tell me why you gave plus that type.
< 1261792397 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :what can we do?
< 1261792405 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i will when im done :p
< 1261792418 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, we can existentially close of the s variable!
< 1261792423 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :\s:SUM -> true && first(s,z) && second(s,1) :: S -> T / N
< 1261792426 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but this then becomes....
< 1261792428 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Then say my name when you're done.
< 1261792459 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::|
< 1261792462 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no keep reading
< 1261792463 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :were almost there
< 1261792487 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :\z -> exists states (\s:SUM -> true && first(s,z) && second(s,1)) :: N -> T / N
< 1261792494 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :er sorry
< 1261792497 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :not quite that far :p
< 1261792503 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :exists states (\s:SUM -> true && first(s,z) && second(s,1)) :: T / N
< 1261792512 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Darn, no alternative activity comes to mind. I'll have to keep reading.
< 1261792527 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but now wait, z isnt _technically_ a bound variable
< 1261792548 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so we have to bind it, but we dont want to do existential, since we got z by removing "a two"
< 1261792550 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so we do a lambda:
< 1261792555 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :\z -> exists states (\s:SUM -> true && first(s,z) && second(s,1)) :: N -> T / N
< 1261792578 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and now we have an N -> T that "a two" :: (N -> T) -> T can combine with!
< 1261792594 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so we put them together to get
< 1261792602 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Though I'm not reading so much as checking to see whether you're answering my question yet.
< 1261792613 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :exists [z : z <- [1..], z = 2] (\z -> exists states (\s:SUM -> true && first(s,z) && second(s,1))) :: T / N
< 1261792622 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :UORYGL
< 1261792631 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :fucking fine
< 1261792641 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :let me stop this ALMOST FINISHED EXPLANATION
< 1261792646 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so i can answer your question
< 1261792651 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Thank you very much.
< 1261792658 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :LETS HOPE YOU REMEMBER WHERE WE FUCKING WERE
< 1261792712 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the idea is to try and force the language to allow _only_ primitive combinations of functions (ie the kind of combinations you can type into a REPL) which involve ONLY forks of two functions
< 1261792729 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Forks?
< 1261792731 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yes
< 1261792733 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :like in J
< 1261792741 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I'm not familiar with J.
< 1261792755 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :fork f g h z = f (g x) (h x)
< 1261792762 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so the classic definition of avg is
< 1261792779 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :avg = fork (+) len (/)
< 1261792784 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :er
< 1261792785 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well
< 1261792790 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :for (/) (+) len
< 1261792791 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::p
< 1261792823 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :where + should be the summation operation
< 1261792824 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :whatever
< 1261792827 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Right.
< 1261792845 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :since fork (/) (foldr (+) 0) len = \xs (/) (foldr (+) 0 xs) (len xs)
< 1261792864 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so then how do you force plus to be a fork-able function?
< 1261792872 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, thats where the language-y stuff comes in
< 1261792887 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :just say plus is a predicate that specifies that kind of thing its argument is
< 1261792889 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :e.g.
< 1261792900 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :all plus does is \s:SUM -> true
< 1261792912 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so that if you do
< 1261792918 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :plus a_state
< 1261792927 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :this is true
< 1261792936 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and, by assertion, s is a SUM
< 1261792951 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :(so the :SUM thing kind of is an assertion of type, rather than a restriction on type)
< 1261792956 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Though I've not thought about it, it sounds a lot like you're saying, "I want my language to allow only oranges. Now, how do we represent an apple as an orange?"
< 1261792964 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :exactly.
< 1261792992 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if you want your language to be purely logical (Prolog) you have to represent addition some special way
< 1261793005 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Where "apple" and "orange" are mutually exclusive concepts.
< 1261793005 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if you want your language to be purely functional (Haskell) you have to represent loops some special way
< 1261793006 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :etc etc
< 1261793013 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :nope, theyre NOT mutually exclusive
< 1261793021 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :theyre just very different perspectives on things
< 1261793023 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so, to continue
< 1261793054 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you've now figured out how to satisfy "a two"'s argument
< 1261793055 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :"Apple" and "orange" are mutually exclusive. You're denying that my analogy applies.
< 1261793059 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Which is precisely what I expected.
< 1261793063 0 :oerjan!unknown@unknown.invalid QUIT :"Good night"
< 1261793066 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :BOTH ARE FRUITS
< 1261793068 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::|
< 1261793069 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :>|
< 1261793079 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you've done so and gotten back exists [z : z <- [1..], z = 2] (\z -> exists states (\s:SUM -> true && first(s,z) && second(s,1))) :: T / N
< 1261793088 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which is GREAT, because this is a basic value
< 1261793098 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but wait, its not a sensible meaning
< 1261793106 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :it still needs an N
< 1261793107 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::(
< 1261793113 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but we dont HAVE an N!
< 1261793114 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :what can we do
< 1261793115 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :?
< 1261793126 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, we can ask which N will make it sensible!
< 1261793132 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I think I'm not your intended audience.
< 1261793141 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but now? stick third(s,w) in there at the appropriate place
< 1261793152 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :exists [z : z <- [1..], z = 2] (\z -> exists states (\s:SUM -> true && first(s,z) && second(s,1) && third(s,z))) :: T
< 1261793161 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but now this has an unbound variable z
< 1261793164 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so we have to close it
< 1261793167 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Which means I'm just being distracted and should get back to something useful.
< 1261793169 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but how can we close it? well, lambdas.
< 1261793189 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :woops, this should be w
< 1261793192 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :since we have z already
< 1261793196 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :\w -> exists [z : z <- [1..], z = 2] (\z -> exists states (\s:SUM -> true && first(s,z) && second(s,1) && third(s,w))) :: N -> T
< 1261793207 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but alas, this is _still_ not a value
< 1261793218 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :what can we do?
< 1261793226 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :we can "question" it:
< 1261793236 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which [1..] (\w -> exists [z : z <- [1..], z = 2] (\z -> exists states (\s:SUM -> true && first(s,z) && second(s,1) && third(s,w)))) :: t
< 1261793258 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :where which is like
< 1261793276 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :ACTION nods in a way that expresses that he believes that his suspicion has been confirmed.
< 1261793296 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which x:xs f = if (f x) then x else which xs f
< 1261793318 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and which [1..] (\w -> ...) is of type N
< 1261793333 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and we can definitely display one of those!
< 1261793334 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :3
< 1261793357 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :this is how my esolang is going to calculate 1 + 2 :D
< 1261793363 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :er
< 1261793365 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :1 plus a two
< 1261793374 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :similar for 1 + 2 but less crazy
< 1261793410 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or, since we're being haskellish
< 1261793417 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :1 `plus` (a two)
< 1261793426 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I keep coming back to this conversation. It would be easier for me to leave if I explicitly closed my end and you acknowledged the closure.
< 1261793429 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :So, see you.
< 1261793436 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :aww :(
< 1261793446 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :uorygl doesnt like my esolang :|
< 1261793477 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Your esolang is probably interesting, but I must admit I can't find interest in what you're saying.
< 1261793489 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, i was giving an evaluation trace
< 1261793493 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :who COULD find interest
< 1261793504 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :If your purpose is to interest me, you should answer my questions and say little else.
< 1261793515 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well ask me a question then
< 1261793527 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you sort of interrupted an explanation i was giving to Gracenotes, so...
< 1261793532 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you got the rest of it
< 1261793537 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :then you started asking queeestions
< 1261793538 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and its like
< 1261793546 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i was in the middle of explaining something, you demanded i restart
< 1261793547 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :fine
< 1261793548 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::|
< 1261793550 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Okay. I felt I would have been interrupting you, since you were saying so much.
< 1261793581 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :You don't have to be interesting. Did I imply that I wanted that?
< 1261793590 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :s/be interesting/interest me/
< 1261793616 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Anyway, my question, if you want to answer it, is what it means for a fork to be "of" two functions.
< 1261793628 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :In fork f g h x, what's that a fork of?
< 1261793635 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :anyway
< 1261793637 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :uh
< 1261793642 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :what do you mean
< 1261793665 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Well, you said "only primitive combinations of functions which involve only forks of two functions".
< 1261793677 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :fork :: forall a, b, c. (a -> b) -> (a -> b) -> (b -> c) -> c
< 1261793685 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i defined fork earlier :|
< 1261793696 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :fork f g h x = f (g x) (h x)
< 1261793705 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Right.
< 1261793713 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :my types are not matching my definitions but whatever
< 1261793715 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you get the point
< 1261793735 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :So is fork (/) (+) len a fork of (+) and len, or what?
< 1261793762 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :fork :: forall a, b, c. (b -> c) -> (a -> b) -> (a -> b) -> a -> c
< 1261793791 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :(b -> b -> c), not (b -> b), I think.
< 1261793802 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :fork (/) (+) is a higher order function \f -> \x -> (+ x) / (f x)
< 1261793813 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no, its (b -> c)
< 1261793839 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :remember tho, i mistyped + instead of like... foldr (+)
< 1261793875 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :What I'm trying to understand is your usage of "of", though.
< 1261793885 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :oh ok
< 1261793894 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you mean when i said that i wanted everything to be forks of functions
< 1261793894 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :right
< 1261793895 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ok
< 1261793897 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :what i meant is
< 1261793935 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :a fork of f and g is: forsome h. \x -> h (f x) (g x)
< 1261793968 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :So fork f g h x is a fork of g and h.
< 1261793986 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yes
< 1261794131 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :ACTION ponders fork.
< 1261794166 0 :adam_d_!unknown@unknown.invalid QUIT :Read error: 110 (Connection timed out)
< 1261794213 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :There's an arrow operation that does that. Something like (&&&) :: ar a b -> ar c d -> ar (a,c) (b,d)
< 1261794216 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :But anyway!
< 1261794236 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :maybe. i dont know what its like in haskell
< 1261794253 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Are you familiar with arrows in Haskell?
< 1261794258 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :nope
< 1261794339 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :They're things that look like functions. Something is an arrow if it has three operations: turning a function into one, composing two of them, and "fork"ing two of them into one.
< 1261794367 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Except that's not really fork; it's more like (&&&) f g (x,y) = (f x, g y). You can make fork out of it.
< 1261794401 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Lessee. fork f g h = f . (g &&& h) . (\x -> (x,x))
< 1261794410 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Where . is the composition operator.
< 1261794415 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :But anyway! :-P
< 1261794437 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i know what . is in haskell :P
< 1261794454 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and i think you mean
< 1261794481 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :eh.. no youre right. :D
< 1261794488 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so yeah
< 1261794490 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :anyway
< 1261794501 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Well, I said that because . only works for actual functions, not arrow things in general.
< 1261794535 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the evaluation of "1 + a two" is such that a lot of it is not written (e.g. the extraction of "a two" is not explicit)
< 1261794546 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :(in that its done by the interpreter)
< 1261794557 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :ACTION ponders what "1 plus a two" would look like if it were done with arrows.
< 1261794564 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but infact maybe you _could_ do it yourself
< 1261794571 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :a two: 1 +
< 1261794587 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and this evaluates to 3 as well
< 1261794596 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Let's use @ for an arrow: a @ b is a "function" taking a and returning b.
< 1261794600 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which lets you use functions normally
< 1261794607 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :except that + is not defined as Int -> Int -> Int
< 1261794624 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but rather as State -> Bool / Int, Int, Int
< 1261794681 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :"Plus" could be (N,N) @ N, "1" could be () @ N, "a two" could likewise be () @ N...
< 1261794703 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :You can use arrow operators to combine those into () @ N the right way.
< 1261794736 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i really should write the interp for this
< 1261794740 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Yes!
< 1261794799 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i like the idea tho man
< 1261794800 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :omg
< 1261794809 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :we have to extend it to quantifiers tho
< 1261794832 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :by we i mean me
< 1261794835 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but im talking to you, so
< 1261794853 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :nah there can be real functions
< 1261794871 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :"A two" isn't really an N, though; you said that.
< 1261794871 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no! haha! there wont be
< 1261794876 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :right
< 1261794880 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"a two" is (N -> T) -> T
< 1261794903 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :If we define a @ b as a -> (b -> T) -> T, then "a two" is () @ N.
< 1261794923 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :specifically, "a two" == \q.Ex:(x = 2)[q(x)]
< 1261794957 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :hmm yes
< 1261795123 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Though what you say makes me want to say stuff of my own. :-)
< 1261795134 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::)
< 1261795197 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Let's call P a point concept, a specific thing, where anything you might refer to is exactly one point concept.
< 1261795212 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so i think "a" would infact be defined as E*
< 1261795249 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :"That orange over there" is a phrase referring to a point concept. There is exactly one thing that you're talking about.
< 1261795269 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yes
< 1261795271 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its a deictic
< 1261795272 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::P
< 1261795289 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :deictic terms are the only referentials really
< 1261795305 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but even "that", while being deictic, is a quantifier
< 1261795308 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :ACTION lets his browser look up the word "deictic".
< 1261795320 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its just a quantifier that has a use of a bound variable
< 1261795326 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :P -> T is a sort of region concept, a type of thing. "Orange" is a region concept, I guess.
< 1261795327 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :bound globals, really
< 1261795372 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :that f g = exists [x : x == the_global, f x] g
< 1261795384 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Let's say R = P -> T.
< 1261795390 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ok
< 1261795398 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Nouns tend to denote Rs, and DPs tend to denote Ps.
< 1261795410 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"point" concepts are denoted E, btw
< 1261795411 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::p
< 1261795416 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, in semantics, e
< 1261795452 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :(you know, we dont use -> in semantics? we use <,>, following church. its horrible. a -> b -> c == >
< 1261795509 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Something that's attested is DPs denoting Rs instead of Ps, which is too bad.
< 1261795543 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Now, let's pretend English is a subject-dropping language; it doesn't really matter.
< 1261795577 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its actually rare that DPs actually point
< 1261795582 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Verbs can stand alone as sentences, but they are usually modified by subjects, direct objects, indirect objects, and prepositional phrases.
< 1261795583 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ignoring "that dog"
< 1261795595 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"the cat" does not actually point
< 1261795597 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :nor does "John"
< 1261795613 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :"John" doesn't actually point?
< 1261795616 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :nope!
< 1261795623 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, it sort of does actually
< 1261795635 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"John" can be one of two things
< 1261795641 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :either an NP, which is a predicate like "cat"
< 1261795660 0 :Slereah!unknown@unknown.invalid QUIT :Read error: 60 (Operation timed out)
< 1261795661 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or a deictic DP, with a covert deictic existential quantifier
< 1261795674 0 :BeholdMyGlory!unknown@unknown.invalid QUIT :Remote closed the connection
< 1261795676 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Intuitively, "John is eating" and "Somebody named John is eating" mean different things.
< 1261795678 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the idea is that when you say "John" as a DP, as in "John danced"
< 1261795691 0 :Slereah!n=Slereah@ANantes-259-1-71-77.w92-135.abo.wanadoo.fr JOIN :#esoteric
< 1261795702 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :sure sure but "Somebody named 'John' is eating" is overly something even more complex
< 1261795713 0 :jpc!n=jw@unaffiliated/javawizard2539 JOIN :#esoteric
< 1261795726 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :we think that "John danced" is really "NOM John danced"
< 1261795735 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :where NOM is roughly "Some" only a covert some
< 1261795737 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :notice,
< 1261795743 0 :Slereah!unknown@unknown.invalid PRIVMSG #esoteric :nom nom nom
< 1261795746 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"John danced" is the same as "Some 'John' danced"
< 1261795754 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :except where you have someone in mind
< 1261795774 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"Some 'John' who I'm thinking of danced"
< 1261795793 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :at least, this is what you have to say to fully account for the semantics of english
< 1261795807 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :without being obnoxious and saying that there's either
< 1261795817 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :a) 10 different versions of the verb "eat"
< 1261795841 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I still think that intuitively, "John is eating" and "Some John who I'm thinking of is eating" mean different things. The former is ambiguous, the latter is inspecific.
< 1261795848 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :b) 10 different versions of "the"
< 1261795859 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, it DOES mean something different
< 1261795875 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because the meaning of "Some John who I'm thinking of is eating" is an actual english sentence with a complex meaning
< 1261795886 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :see the problem is that like
< 1261795904 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the quantifier inside of "NOM" is not the SAME as the quantifier "some ... who I'm thinking of"
< 1261795904 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :You seem to be claiming that they do mean the same thing.
< 1261795912 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :theyre roughly the same, right
< 1261795922 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but insofar as your internal representation is concerned, they're not
< 1261795938 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Huh.
< 1261795943 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and representationally they're different
< 1261795952 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :in the same way that "1 + 2" and "2 + 1" are different haskell expressions
< 1261795958 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but if you evaluate them they mean the same thing
< 1261795980 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if you "evaluate" the two sentences "John is eating" and "Some John that I'm thinking of is eating", WHILE you're thinking of that particular John
< 1261795990 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you wont be able to find a difference in meaning
< 1261796029 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Let's say that "John is eating" does refer to a specific John, though which John it is may be undeterminable.
< 1261796040 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :undeterminable by the listener
< 1261796041 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :not by you
< 1261796070 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :when we reflect upon the meanings of sentences, we're not looking at whether or not the sentence is true, nor what makes the sentences true, we're looking at the form of the meaning
< 1261796119 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the form of the meaning of "John is eating" really does seem to have something like a quantifier in it, at when you represent the meaning using the normal modes of meaning representation.
< 1261796146 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if all we ever said were things like "John is eating" this wouldnt be an issue
< 1261796160 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :hell, if all we said were things like "John is eating" and "all dogs are brown" this wouldnt be an issue
< 1261796177 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the issue is "John is eating something"
< 1261796189 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and
< 1261796199 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :So I'm trying to create the concept of "the P referred to by a DP". I think in order to do that, I have to find three mutually correlated properties, and say that this new concept is the thing that they are related by being correlated with.
< 1261796199 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"The John that I know is eating something"
< 1261796228 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :what?
< 1261796230 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I think I'm getting caught up in Philosopher's Molasses.
< 1261796239 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no, semanticists molasses :p
< 1261796242 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but such is language!
< 1261796257 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :to account for object quantification you need a whole mess of shit
< 1261796260 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Rationalist's Molasses.
< 1261796262 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :there are a number of options
< 1261796272 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :in ONE option, you could ALMOST get away wit h John being deictic
< 1261796284 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :except then you have to have as many words "John" as know people named John
< 1261796299 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :AND you also have to have another word "John" that means "person named 'John'"
< 1261796317 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I'm pondering when it's valid to postulate a concept.
< 1261796351 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and at the same time you STILL need to have purely deictic terms like "that"
< 1261796367 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or some covert terms that seem to be genuinely deictic
< 1261796401 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and then theres the problem that in many languages, even PROPER NOUNS must be used with "the"
< 1261796402 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :e.g.
< 1261796412 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :in greek, you dont say "John is dancing" you say "The John is dancing"
< 1261796432 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Anyway, we should stop trying to find the Deep Theoretical Platonic Truth until we figure out how it's related to the Shallow Empirical Observable Truth.
< 1261796440 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the same "the" (an 'o' or there abouts eg 'o janos') that you use to say "the cat"
< 1261796453 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :there is no shallow empirical observable truth :D
< 1261796468 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :quantum mechanics and that berkeley dude has shown us this
< 1261796480 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :On the contrary!
< 1261796490 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :look, the evidence that "John" is really a deictic quantifier is quite strong
< 1261796522 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yes, it seems like "John is eating" points to some particular person John (because it does) and that it has a different meaning that "Some John is eating" (because it does)
< 1261796536 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :If I look at a glass, I know that I see a glass.
< 1261796543 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Is there really a glass there? Almost certainly.
< 1261796558 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :The presence of that glass is the shallow empirical observable truth.
< 1261796558 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but that does NOT mean that "John" here by itself, as the smallest meaningful object that contains the letters "John", is infact the thing doing the pointing.
< 1261796574 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you dont know you see a glass, you THINK you see a glass
< 1261796595 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the most you know is that you're experiencing what it would be like to see a glass
< 1261796604 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or what you would call a glass
< 1261796655 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :thats not to say you dont have a very good reason to think that
< 1261796655 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Sure. In any case, we know *something* upon seeing a glass; whatever logic is based on, let us call that knowledge.
< 1261796667 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :s/logic is based on/the premises of logical reasoning are/
< 1261796681 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but that reason is merely 500 million years of evolution hard-coding some very sophisticated philosophical argumentation
< 1261796691 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so seeing a glass is NOT shallow at all
< 1261796712 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its just that the depth is masked by the fact that conscious experience is a very recent thing that has very LITTLE access to cognitive processes
< 1261796724 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :It's shallow in that it's a very familiar and intuitive sort of thing.
< 1261796729 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yes
< 1261796738 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but familiar and intuitive is irrelevant
< 1261796748 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :when we're doing semantics, we're not asking what is intuitive
< 1261796754 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :we're asking what is real
< 1261796758 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or accurate, at least.
< 1261796782 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :science has revealed again and again that the intuitive understanding of the world is usually wrong
< 1261796783 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I guess it depends on whose perspective you're speaking of. From a human's perspective, it's a shallow truth. From a computer's perspective, it's presumably a pretty deep one.
< 1261796804 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :motion is not newtonian, there is no such thing as simultaneous, and you are not the best authority on the contents of your own mindbrainthing
< 1261796814 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :sure, its a shallow truth
< 1261796816 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :like i said
< 1261796817 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :that means nothing
< 1261796825 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because were not ASKING what the shallow truth is
< 1261796836 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :when you ask a person what does "fido is a dog" mean, they just repeat the sentence back at you
< 1261796842 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"why, it means that fido is a dog! duh!"
< 1261796853 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but thats not a meaning
< 1261796863 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :thats not what your mental representation of the meaning is
< 1261796865 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :surely not!
< 1261796880 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because "fido is a dog" is a string of letters/sounds!
< 1261796902 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and its almost certainly not the case that our representations of meaning are in terms of abstract syntax trees
< 1261796936 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because then then bilingual speakers would never be able to say that "rex is a cat" and "rex est un chat" mean the same thing
< 1261796937 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :But our deep knowledge is based on our shallow knowledge and it exists for the purpose of predicting what our next shallow knowledge will be.
< 1261796948 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because french and english probably dont have the same abstract syntax in that regard
< 1261796953 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yes but guess what
< 1261796965 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :our shallow knowledge of LANGUAGE is buttressed by an enormously complex linguistic faculty
< 1261796990 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :what reason do you have to believe that when you learn the word "fido" that you're just learning what it points to?
< 1261797000 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :this is NOT part of your shallow experience
< 1261797009 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because now we're in the realm of cognitive science/psychology/whatever
< 1261797022 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :your shallow experience of the world does not include the details of name acquisition
< 1261797033 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :it includes the experience of seeing someone point to an animal and go "fido"
< 1261797036 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"fido fido fido"
< 1261797038 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"this is fido"
< 1261797044 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"c'mere fido!"
< 1261797047 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"fido want a treat?"
< 1261797051 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"thats a good fido"
< 1261797086 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :(oops, sorry, i just used a quantifier in your primary linguistic data! D: you might get the impress that fido is really a predicate!)
< 1261797105 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Hmm, I think we're talking about the deep truth again.
< 1261797108 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no, we're not
< 1261797119 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because you're saying that the "Shallow" meaning of "fido" is the dog itself
< 1261797122 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but how do you know this?
< 1261797129 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :theres nothing in your experience of the world that shows this
< 1261797145 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you have to make an ASSUMPTION about how people learn the meaning of words
< 1261797172 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :your ASSUMPTION is that "fido" is by default going to be mapped to the dog in question, not to some abstract "fidoness" quality
< 1261797179 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but thats the whole thing you're ARGUING!
< 1261797180 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :We're talking about things that are themselves deep truth.
< 1261797199 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :The shallow truth of semantics is whatever we can observe and feel about it.
< 1261797207 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but you CANT observe semantics
< 1261797221 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and you cant FEEL everything either
< 1261797224 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :like i said earlier
< 1261797231 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you _FEEL_ that when you typed "John"
< 1261797232 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :If semantics has no observable or feelable consequences, there's no reason to discuss it.
< 1261797236 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :that this whole thing referred to someone
< 1261797242 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, sure, in a way it DID refer to someone in particular
< 1261797254 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but that doesnt mean that "John" those four letters are really all there is to that phrase
< 1261797262 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :nor that that person is all there is to that meaning
< 1261797277 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Great. So I can see some shallow truth there.
< 1261797283 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no, you cant
< 1261797297 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Um...
< 1261797307 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :all you can see is the fact that the string of letters "John" seems to refer to a particular person.
< 1261797308 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :thats it.
< 1261797314 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :that doesnt tell you whether or not thats ALL it does
< 1261797327 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Right. The shallow truth is that "John" probably refers to a particular person.
< 1261797342 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :like i said
< 1261797344 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :deictics DO refer
< 1261797351 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and "John" can be a deictic
< 1261797355 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but its STILL a quantifier as well
< 1261797366 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because its a quantifier with has a deictic element
< 1261797370 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or, more accurately
< 1261797382 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its a predicate that combines with a quantifier that has a deictic element inside it
< 1261797398 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :suppose that J was _that particular John_
< 1261797414 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the current best guess is that "John" in "John is eating" has the meaning roughly like
< 1261797453 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :\p -> Ex[x = J & calledJohn(x)]
< 1261797467 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you've GOT the deicticy thing in there
< 1261797484 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you're referring directly to the person, in that there IS the use of J in there
< 1261797498 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but that does NOT mean that the whole thing isnt a quantifier, ok
< 1261797535 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :infact, the root word "John" (not the phrase "John" in "John is eating") is NOT the thing thats contributing the referentiality
< 1261797540 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its the quantifier!
< 1261797561 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :\q, p -> Ex[x = J & p(x) & q(x)]
< 1261797587 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and this quantifier in english (but not in greek maybe?) happens to be phonologically empty
< 1261797602 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :So, you mentioned "the current best guess". What's the question we're guessing the answer to?
< 1261797615 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :what the meaning of "John" looks like
< 1261797629 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :is it the person john, or some quantifier, or whatever
< 1261797632 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :thats the question
< 1261797662 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the assumption that its just a reference to some person in particular just _doesnt work_ with the rest of the meanings of sentences
< 1261797686 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :now we can waffle about the meaning of "meaning"
< 1261797686 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :So, "What does the meaning of 'John' look like?" Now, I can't look at a meaning and see what it looks like, so what's the shallow truth we're trying to figure out by answering that question?
< 1261797695 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and say that meaning is the intention behind the expression
< 1261797699 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but thats way too loose
< 1261797712 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because then the meaning of an expression is whatever the person intends it to be, regardless of the conventions of the language
< 1261797728 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"John is eating" means "Mary danced" because i INTENDED it to
< 1261797732 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well no, sorry, it doesnt
< 1261797742 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :like i said
< 1261797748 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :semantics is NOT a shallow truth
< 1261797768 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which is why you cant just tell me that John refers to the person because thats the shallow truth of it
< 1261797773 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I find that instead of waffling about meanings, it's better to say what we'd like to say without using the word at all.
< 1261797777 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because you're saying the meaning of John is a reference to a person
< 1261797788 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but the meaning of expressions is not a shallow truth!
< 1261797802 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, uorygl
< 1261797812 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :when you can figure out what you're trying to say without using the word meaning, be my guess :P
< 1261797814 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :guest*
< 1261797841 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or without using any words that covertly incorporate notions of meaning
< 1261797846 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :What should we conclude upon hearing "John is eating"?
< 1261797861 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :What do people want when they say "John is eating"?
< 1261797894 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Combine those: What do people want us to conclude when they say "John is eating"?
< 1261797917 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :we should conclude that the speaker believes there is a person that the speaker believes is called john with whom the speaker knows, and assumes the hearer knows as well, and that this person is, at this very moment, engaged in a process of eating something or other which the speaker doesnt know the identity of, or which the speaker does not feel the identity of to be relevant
< 1261797944 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :we should also conclude that the speaker believes that this is somehow relevant to the conversation were having and that i will be able to integrate this into my understanding of the situation
< 1261797946 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Indeed, there's a whole bunch we should conclude.
< 1261797951 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yes
< 1261797958 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :except that is not the meaning of the sentence "John is eating"
< 1261797978 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because when someone says "John is eating" they are not conveying to you "I believe you know who John is"
< 1261797985 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because if they were
< 1261798023 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, there are all sorts of because
< 1261798024 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but
< 1261798040 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if I said that Frank was wrong when he said that "John is eating"
< 1261798075 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :this is definitely not going to be the case if Frank didn't actually think I knew who John was
< 1261798088 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Right.
< 1261798098 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but all of this hinges on the WORD "meaning"
< 1261798111 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i mean, we can just ask what we should concluce
< 1261798132 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but that leads to a whole world of shit beyond just LANGUAGE
< 1261798141 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :it leads to psychology of action
< 1261798146 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :inferring why people do things
< 1261798146 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :etc
< 1261798154 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and that can lead to inferences about the physical world
< 1261798179 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because "john died after jumping off the bridge" leads us to conclude that the speaker believes something about jumping off of bridges and death
< 1261798181 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :like say falling
< 1261798182 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and gravity
< 1261798187 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and that yadda yadda
< 1261798202 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :No shallow truth can hinge upon the definition of a word. Unless, of course, said truth is about the word itself.
< 1261798223 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :what we can or should conclude from a sentence is not the meaning of the sentence, its the meaning of the sentence plus a whole shittone of other crap thats brought into the task of understanding
< 1261798235 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ah but thats the thing see
< 1261798243 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you cant even ask what the shallow truth of blah blah blah is
< 1261798250 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because there is no shallow truth of "John"
< 1261798254 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its just a word
< 1261798256 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Anyway:
< 1261798259 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :truth is a property of claims
< 1261798262 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or propositions
< 1261798267 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and "John" is not a proposition
< 1261798278 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Let's call the "real" definition of meaning meaning1, and my definition of meaning meaning2.
< 1261798283 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well
< 1261798288 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :lets not use the word meaning at all
< 1261798295 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :So the meaning1 of "John is eating" does not include the fact that I know who John is, but the meaning2 does.
< 1261798301 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :lets do what semanticists do and say this:
< 1261798315 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Why do we care about the meaning1?
< 1261798340 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :watching Maru yawn in slow motion is perhaps the most satisfying thing I've done today
< 1261798340 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if you know the "meaning" of a sentence like "John is eating", you know what is required of the world for it to be true or not
< 1261798355 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you also know some other stuff, but at the very least you know what is required for it to be "literally true"
< 1261798397 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :semantics is the study of the literal content of expressions
< 1261798403 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Well, let me take a different route.
< 1261798411 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and, it turns out, in order to understand the WHOLE of the "meaning" of "John is eating"
< 1261798416 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :that is, to include your meaning1 as well
< 1261798419 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I think you would agree that "Oh no!" doesn't have a truth value.
< 1261798425 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :How do you know that it doesn't have a truth value?
< 1261798426 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you have to know the litteral content
< 1261798436 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :And why do you care that it doesn't have a truth value?
< 1261798446 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :it doesnt have a truth value because you cant so "No, you're wrong." when someone says "Oh no!"
< 1261798460 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :since I've sort of been passively wondering what the scope if it all is, how about, say, "John is ugly"?
< 1261798467 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the question is whether or not "Oh no!" is language.
< 1261798477 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its a bunch of sounds you made with your mouth
< 1261798481 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but so is a sneeze
< 1261798484 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :or instead of ugly, some other thing that is 100% an opinion of the speaker
< 1261798502 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :now we might actually accept that its language, sure
< 1261798513 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :lets say its language, ok
< 1261798528 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :So we feel like there's a notion of contradictability.
< 1261798533 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :not at all.
< 1261798543 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i didnt say that ALL linguistic expressions have truth values
< 1261798553 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i said that expressions like "John is dancing" have truth values
< 1261798553 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :When somebody says "You're wrong!" in response to "Oh no!", that makes us feel a specific way.
< 1261798573 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :oh oh sorry i see what you mean
< 1261798580 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well yes, i mean
< 1261798582 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you cant say
< 1261798588 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"yes thats true" to someone's "oh no"
< 1261798594 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :augur: again, how's "John is ugly?"
< 1261798595 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :nor can you say "no thats false"
< 1261798597 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or no thats wrong
< 1261798598 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or whatever
< 1261798602 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :(gracenotes: what about it)
< 1261798605 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :make that a "?, not ?"
< 1261798620 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :oh, in-situ questions. what about it?
< 1261798633 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :augur: it's not something that is provably true or false, yes, what we learned about in grade school as truth vs. opinions
< 1261798647 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :or "Some say John is fugly"
< 1261798666 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"John is ugly" is an assertion
< 1261798671 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :well, that is verifiable, although semantics must still make meaning about what the claim is
< 1261798675 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and, in some very real sense, it can be considered true or false
< 1261798690 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"John is ugly?" with a question mark is a question
< 1261798695 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and so doesnt have a truth value
< 1261798704 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :So...
< 1261798707 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so!
< 1261798715 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :sou desu
< 1261798721 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :sou ka?
< 1261798734 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :what, uorygl
< 1261798736 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :If I know a certain thing, and I hear the sentence "John is eating", I will agree.
< 1261798743 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :sure
< 1261798749 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :this is the kind of meaning that semantics is concerned with
< 1261798757 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the literal sorts of meaning
< 1261798760 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Yes, I think we've come up with a definition of meaning.
< 1261798769 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :not what you can infer from the expression
< 1261798777 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :just what the literal meaning is
< 1261798781 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :john be fugly
< 1261798786 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the literal content, if you will
< 1261798792 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :just know that, when you hear him used in example questions
< 1261798798 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :there is a whole field of exploring the non-literal meanings behind things
< 1261798801 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :he's not truly beautiful :_:
< 1261798802 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :part of that is pragmatics
< 1261798806 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :part of that is psychology
< 1261798807 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I think we can confuse the issue a bit, though.
< 1261798847 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :actually we cant. there are very clear lines that can be drawn between literal meaning, pragmatics, and psychology.
< 1261798856 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Suppose that I and a friend are walking along, and we both see something disgusting. My friend says, "Eew." Am I agreeing?
< 1261798862 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and the problematic aspects are all at the line between pragmatics and psychology.
< 1261798883 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :What if my friend says "Disgusting!"?
< 1261798888 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :that depends on what you mean by "agree"!
< 1261798920 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Well, this definition of "meaning" that I came up with hinges on what "agreement" is.
< 1261798930 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :there are at least two words in english that are written "agree"
< 1261798933 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or two senses of the same word
< 1261798940 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :one is "share an opinion"
< 1261798943 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :as in
< 1261798974 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"Alexis expressed disgust at the food. I agreed inside, but didn't say anything."
< 1261798976 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or
< 1261798989 0 :FireFly!unknown@unknown.invalid QUIT :"Leaving"
< 1261798992 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :augur: if you work in semantics, you might have to explain this depressingly often :| but better to introduce non-linguists, I suppose.
< 1261799005 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the other can mean "express concurrance on a matter"
< 1261799006 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :as in
< 1261799014 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"Alexis didn't agree to the terms of the deal"
< 1261799023 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :ACTION nods.
< 1261799033 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"even if inside Alexis really liked the deal, her bosses insisted that she not agree to it"
< 1261799086 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Gracenotes: SO often. you have no idea how many times, when working on an extraordinarily complicated issue like what the meaning of "Fido is a dog" is, someone will say "Fido is a dog just means Fido is a dog! It's simple!"
< 1261799090 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well no, its not simple, sorry
< 1261799095 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you're just DESIGNED TO UNDERSTAND IT
< 1261799101 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :it is a black art
< 1261799108 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if it were truly simple, my calculator could understand what it means
< 1261799110 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :you must have secret semanticist rituals
< 1261799114 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :thats the true test
< 1261799124 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :simplicity is demonstrable: program it.
< 1261799136 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :thats how we know that calculus, for instance, is mindnumbingly simple, when it comes down to it
< 1261799161 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :all the calculus youve ever done in your life to date could be done in a computer program in a few minutes or hours
< 1261799165 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ALL of it
< 1261799176 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and a computer isnt anywhere near as smart as a person
< 1261799191 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well if calculus is so easy that a computer can do it, it must be easy
< 1261799196 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :regardless of how difficult humans find it
< 1261799197 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Is it okay if I interpret "program" as meaning "express in a computer language", where a "computer language" is any language that expresses details that a computer deals with intimately?
< 1261799208 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :sure!
< 1261799213 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :infact
< 1261799215 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Great.
< 1261799218 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :so, has anyone bothered making a language --(parse)--> syntax --(interpret)--> semantics tool, at some point?
< 1261799225 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :lets say that "program" means "express in some form of logic"
< 1261799240 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :since programming languages are just logics.
< 1261799251 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :I'd imagine there must be. But fragments of it, which I'm sure is not perfect, otherwise it's what we'd all be using
< 1261799254 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Well, that's kind of ambiguous, isn't it? Straightforward English is arguably a form of logic.
< 1261799254 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yeah, they have
< 1261799257 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but they tend to suck.
< 1261799263 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well no
< 1261799266 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :english is far from it
< 1261799271 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Euclid wrote in straightforward English, for strange values of "English".
< 1261799283 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Euclid wrote in straightforward Greek ;)
< 1261799297 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :what i should have said is
< 1261799300 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"in some Logic"
< 1261799308 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :where a Logic is a well defined formal system
< 1261799314 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :"If English was good enough for Jesus, it's good enough for America!" --a straw man
< 1261799318 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :like first order predicate calculus or whatever
< 1261799329 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Okay, that works.
< 1261799330 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but sure, programming language
< 1261799332 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i dont care
< 1261799356 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its just easier to expression certain things in a language like PC2 or HPC or whatever
< 1261799369 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :~ SOL/HOL
< 1261799377 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :to express**
< 1261799383 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but thats what i was doing earlier!
< 1261799386 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and you complained!
< 1261799387 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::P
< 1261799398 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Hmm. :-)
< 1261799404 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if you try to give a good, well defined meaning for "John"
< 1261799413 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and your well defined meaning is a referential
< 1261799433 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :(that is, a symbol referring to, or behaving as if it were, the person)
< 1261799446 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :(e.g. your logic says the meaning of "John" is J)
< 1261799463 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :then you will, inevitably, conclude that there must be an infinite number of distinct words "John"
< 1261799493 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"John_1" refers to John Lennon, "John_2" refers to JFK, "John_3" refers to the pizza delivery boy, ...
< 1261799500 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :for all of the John's that you know
< 1261799510 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Why would those have to be distinct words?
< 1261799525 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :It would make a lot of sense, I think, for them to be distinct senses of a single word.
< 1261799527 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well explain how you'd distinguish which is meant!
< 1261799541 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :tell me how a single word "John" could be used to refer to INDIVIDUAL people
< 1261799547 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :when when there are multiple Johns
< 1261799552 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I dunno, the same way that we distinguish between different senses of a word like "set"?
< 1261799572 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ah but there are probably multiple words "set"!
< 1261799581 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :just because they sound the same doesnt mean theyre the same word, keep in mind
< 1261799582 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Why would we call those multiple words?
< 1261799586 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I agree.
< 1261799596 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"set" like a movie set
< 1261799604 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"set" like what you do to a variable
< 1261799610 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :probably different words
< 1261799614 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :But I like to define words by the conjunction of spelling, pronunciation, and etymology.
< 1261799615 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :now maybe you have a smaller kind of difference
< 1261799618 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"mostly the same but not quite"
< 1261799635 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ok, so now "John" is a single word with multiple subtly different senses
< 1261799636 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ok fine
< 1261799643 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :If they have the same spelling, they're pronounced the same way, and their reason for being a word is the same, they're the same word.
< 1261799649 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :now tell me what the representation in your logic is.
< 1261799659 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well yes, words are like
< 1261799667 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :words are pairs, at least, of form and sound
< 1261799669 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :er
< 1261799670 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :form and meaning
< 1261799674 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :what saussure called a Sign
< 1261799690 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :theres probably a bit more to it than that
< 1261799711 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Hmm, what you're doing is a lot like asking me for the simplest explanation of a phenomenon.
< 1261799717 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i AM, yes
< 1261799722 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i mean
< 1261799722 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :look
< 1261799737 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you seemed to be up to the challenge of giving me pseudocode for this
< 1261799739 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so
< 1261799748 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if "John" is one word with multiple senses
< 1261799752 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :give me pseudocode.
< 1261799775 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :give me pseudocode for "John is dancing"
< 1261799789 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and ignore all the extraneous shit like what the "is" and the "ing" and the tense and shit are doing
< 1261799805 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i dont care about that (unless its relevant to your explanation of the pseudocode for "John")
< 1261799824 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :just give me, right now, the pseudocode.
< 1261799825 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :do it.
< 1261799833 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :ACTION ponders.
< 1261799862 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :A person is dancing. That person's name is John. Nothing else I could be referring to is named John. Therefore, I say "John is dancing".
< 1261799983 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Did I explain the phenomenon?
< 1261800051 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :nope!
< 1261800061 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :not in the way you'd accept it
< 1261800066 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because you turned "John" into a predicate!
< 1261800071 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"That person's name is John"
< 1261800083 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Did I attempt to explain the right phenomenon?
< 1261800083 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but thats what _I_ said
< 1261800090 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :sure
< 1261800104 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :whatever you want
< 1261800113 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :just give me the meaning in your pseudocode
< 1261800131 0 :Pthing!n=pthing@cpc11-pres4-0-0-cust168.pres.cable.virginmedia.com JOIN :#esoteric
< 1261800141 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ph man, pthing
< 1261800149 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :were talking linguistics
< 1261800149 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :ACTION tries again.
< 1261800150 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :hardcore like
< 1261800156 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you might not want to stay D:
< 1261800164 0 :Pthing!unknown@unknown.invalid PRIVMSG #esoteric :shut up augur
< 1261800167 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::|
< 1261800175 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :y'mutha
< 1261800193 0 :Pthing!unknown@unknown.invalid PRIVMSG #esoteric :is the perfect relish to any and all conversations in which augur plays a vital part
< 1261800207 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :your mother is the perfect relish?
< 1261800214 0 :Pthing!unknown@unknown.invalid PRIVMSG #esoteric :no
< 1261800218 0 :Pthing!unknown@unknown.invalid PRIVMSG #esoteric :shut up augur
< 1261800219 0 :Pthing!unknown@unknown.invalid PRIVMSG #esoteric :is
< 1261800220 0 :Pthing!unknown@unknown.invalid PRIVMSG #esoteric :shut up augur
< 1261800276 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :A person is dancing. "John" evokes that person. "John" does not evoke anything else. Q.E.D.
< 1261800280 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Er.
< 1261800297 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :A person is dancing. "John" evokes that person. "John" does not evoke anything else. I want to use a word that evokes only that person. Q.E.D.
< 1261800312 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :this is your pseudocode?
< 1261800323 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Yes?
< 1261800336 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but it does not do what you said!
< 1261800348 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or, rather, it does not do what you wanted it to do
< 1261800379 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Given the statement I just made, one can conclude that I will use the word "John" to refer to the dancing person.
< 1261800389 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :in that, the word "John" here surely maps to "'John' evokes that person. 'John' does not evoke anything else."
< 1261800403 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and minimally also,
< 1261800411 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"a person"
< 1261800427 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :that is to say, the word john maybe denotes a particular person
< 1261800470 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but the majority of the words contribution, infact, ALL of the contribution of the words distinguishing feature (being written 'John' instead of 'Mary') is NOT the particular person
< 1261800471 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but rather
< 1261800493 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :'"John" evokes that person. "John" does not evoke anything else. I want to use a word that evokes only that person.'
< 1261800508 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you see what i mean?
< 1261800514 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Hmm.
< 1261800530 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :hell, even 'a person' doesnt do what you want unless we interpret it to be some atomic element that means that person
< 1261800536 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the whole thing is nothing but a giant quantifier!
< 1261800565 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"A person that is called John who is the only person in this context that could intend... is dancing"
< 1261800573 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, thats pretty much what i said earlier. :)
< 1261800576 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :How about we ask a different question, like...
< 1261800628 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :How could an intelligent computer represent the sentence "John is dancing"?
< 1261800636 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :sure
< 1261800638 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :whatever you want
< 1261800641 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i dont care how you do it
< 1261800644 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :just give me pseudocode.
< 1261800660 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Awesome.
< 1261800747 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :IsDancing(JohnThePizzaDeliveryGuy)
< 1261800755 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :(Look, suggestively-named Lisp tokens!)
< 1261800767 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and thats the literal meaning of "John"?
< 1261800816 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Well, presumably, this computer knows some things that are related to each other, and has chosen this label the relation JohnThePizzaDeliveryGuy.
< 1261800825 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :sure sure ok
< 1261800844 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so then this computer will always-and-forever interpret "John" as JohnThePizzaDeliveryGuy
< 1261800870 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Well, there's further reason that the computer interprets "John" as this token.
< 1261800881 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ah, well then, you havent given me the literal meaning!
< 1261800887 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I haven't?
< 1261800899 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :youve given me a meaning that has some interpretation of meaning already in it
< 1261800920 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I feel like this has turned into a discussion of rationality, which makes me want to take it to #lesswrong, our rationality channel.
< 1261800941 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no, if we did that, thered be no convo here
< 1261800958 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :since it was quiet until gracenotes and i moved the convo here from proggit
< 1261800968 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :although it was here originally
< 1261800979 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well sure but we werent talking about esolangs then :D
< 1261800989 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :we were talking aboud proggitty things
< 1261800996 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i mean, maybe #lesswrong
< 1261801012 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :if you have a name for your PL, you get a *free* freenode channel for it!
< 1261801015 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :fancy that
< 1261801032 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :indeed!
< 1261801036 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :hence #antigravity! :D
< 1261801048 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :you don't say
< 1261801090 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i do
< 1261801096 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but i dont go there anymore since i was bored of it
< 1261801557 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :quite so
< 1261801599 0 :Gracenotes!unknown@unknown.invalid PRIVMSG #esoteric :now, I'm going to get one of the delicious melted mint chocolate kiss sugar cookies my mom made
< 1261802853 0 :soupdragon!n=somebody@unaffiliated/fax JOIN :#esoteric
< 1261803978 0 :adu!n=ajr@pool-74-96-89-187.washdc.fios.verizon.net JOIN :#esoteric
< 1261804751 0 :ehirdiphone!n=ehirdiph@91.105.122.30 JOIN :#esoteric
< 1261804766 0 :ehirdiphone!unknown@unknown.invalid PRIVMSG #esoteric :http://journal.stuffwithstuff.com/2009/12/26/conditional-binding-with-let-in-magpie/ Interesting control structure.
< 1261804825 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :erm
< 1261804830 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i should write a similar tutorial in ruby
< 1261804847 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :what's interesting about it
< 1261804853 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if value = "1234".to_i then ... else puts "Couldn't parse string." end
< 1261804868 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :SO AMAZING
< 1261804948 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :hate to be a detractor but afaict it's like a bad version of do notation?
< 1261804965 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :everything is a bad version of do notation
< 1261805017 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :oh, well, actually ruby wont do it correctly because ruby defaults to 0 if the string starts with a letter, but...
< 1261805356 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ehirdiphone: did you hear about my awesome idea for an esolang?
< 1261805555 0 :ehirdiphone!unknown@unknown.invalid PRIVMSG #esoteric :augur: Your snippet was nothing like the actual construct.
< 1261805565 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ey?
< 1261805594 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :ehird am I missing something or were you being sarcastic?
< 1261805622 0 :ehirdiphone!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon: Just because a concept is reducible to another concept does not mean it is inferior.
< 1261805635 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :what
< 1261805639 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ehirdiphone: what are you talking about
< 1261805642 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :I agree and I didn't mean to suggest that
< 1261805643 0 :ehirdiphone!unknown@unknown.invalid PRIVMSG #esoteric :He acks the prior art at the end of the post.
< 1261805648 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :humblest apologies bro
< 1261805653 0 :ehirdiphone!unknown@unknown.invalid PRIVMSG #esoteric :augur: His do notation remark
< 1261805665 0 :ehirdiphone!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon: Apologies for what?
< 1261805665 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :oh
< 1261805667 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :wait, what?
< 1261805676 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :for implying that
< 1261805695 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :I don't know what you're talking about ehird.
< 1261806669 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :anyway
< 1261806677 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :did you see my ideas for an esolang, ehird?
< 1261806714 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :I still don't get what's interesting about the language construct...
< 1261806737 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :it's basically the same as try/catch
< 1261806748 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i agree, its nothing amazing
< 1261806755 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but its useful i suppose?
< 1261806768 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :not more useful or less useful than existing ocnstructs, say..
< 1261806769 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but
< 1261807104 0 :ehirdiphone!unknown@unknown.invalid QUIT :"Get Colloquy for iPhone! http://mobile.colloquy.info"
< 1261807602 0 :augur!unknown@unknown.invalid QUIT :Read error: 104 (Connection reset by peer)
< 1261807613 0 :augur!n=augur@c-71-196-120-234.hsd1.fl.comcast.net JOIN :#esoteric
< 1261808307 0 :bsmntbombdood_!unknown@unknown.invalid QUIT :"Leaving"
< 1261808387 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :That conditional binding thing sounds exactly like Haskell's 'maybe', which is a defined function, not a language feature.
< 1261808442 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Oh, the author said so.
< 1261808469 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :uorygl, yeah doesn't seem to be anything interesting about it not sure what ehird was meaning
< 1261808888 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i...
< 1261808892 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :uorygle
< 1261808925 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :I'm not sleepy any more? >.>]
< 1261808928 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :s/]//
< 1261808931 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :uorygl: i think i just made a translation routing from the semantics of functional language to prolog to my esolang
< 1261808937 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :routine**
< 1261808942 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :unintentionally
< 1261808959 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Huh, neat.
< 1261809241 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :first [1] -> first 1:[] -> first (List 1 []) -> first(s,l,w) && list(l,1,[]) -> first(s) && P0(s,l) && P1(s,w) && list(l) && P0(l,1) && P1(l,[])
< 1261809255 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :with closures:
< 1261809262 0 :calamari!unknown@unknown.invalid QUIT :"Leaving"
< 1261809326 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Ww[Es[first(s) && P1(s,w) && El:list(l)[P0(s,l) && P0(l,1) && P1(l,[])]]]
< 1261809374 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and you'd define, in your code, Ww[Es[first(s) && P1(s,w) && El:list(l)[P0(s,1) && P0(l,x)]] = x
< 1261809398 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and thats how you define functions :X
< 1261809459 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :er
< 1261809461 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :that should really be
< 1261809478 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Ww[Es:FIRST[P1(s,w) && El:LIST[P0(s,1) && P0(l,x)]] = x
< 1261809690 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the translation should actually be Ww[Es:FIRST[El:LIST[P0(s,l) && P1(l,1) && P0(l,[])] && P1(s,w)]] sorry
< 1261809767 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :WHATCHU THINK SON
< 1261811964 0 :coppro!unknown@unknown.invalid QUIT :Read error: 54 (Connection reset by peer)
< 1261813050 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :augur what's W?
< 1261813068 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :I guess E is exists, W is forall?
< 1261813074 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :an operator that essentially says "for which w is it true that ..."
< 1261813082 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :hmm
< 1261813087 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so like
< 1261813095 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Wn[1 + 1 = n] => 2
< 1261813118 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :ah I get it, but what abouft Wn[n*n = 4], multivalued?
< 1261813647 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :you know curry has a backend that compiles to prolog?
< 1261813692 0 :MizardX!n=MizardX@unaffiliated/mizardx JOIN :#esoteric
< 1261813715 0 :coppro!n=coppro@unaffiliated/coppro JOIN :#esoteric
< 1261813767 0 :Gracenotes!unknown@unknown.invalid QUIT :Read error: 104 (Connection reset by peer)
< 1261813865 0 :Gracenotes!n=person@wikipedia/Gracenotes JOIN :#esoteric
< 1261814399 0 :clog!unknown@unknown.invalid QUIT :ended
< 1261814400 0 :clog!unknown@unknown.invalid JOIN :#esoteric
< 1261814737 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :wonder what structures you can decide W for..?
< 1261814764 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :probably only really trivial stuff like finite sets
< 1261815194 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon: yes, Wn[n*n = 4] would be multiply valued
< 1261815205 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :infact, it would be like asking that question in prolog
< 1261815211 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :?- x*x = 4.
< 1261815211 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :I see
< 1261815232 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :X = 2.
< 1261815235 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :X = -2.
< 1261815856 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :W with + and * is TC isn't it? you can define 0 = Wn[n+n=n] but I can't see how to define 1 without (.. & ~n = 0) or using A
< 1261815870 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :(on natural numbers)
< 1261816400 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :that's so irritating that you can't define 1...
< 1261816525 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :0 = Wn[n+n=n], 1 = W[n+n=n*n], ~0=1
< 1261816596 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :Prime = Wp[En[Em[nm=p]]]
< 1261816609 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :uh
< 1261816614 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you wouldnt define shit like that
< 1261816616 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :though that includes 1 and 0
< 1261816627 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you would just start by defining succ and shit
< 1261816682 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Wn[succ {} == n] = {{}}
< 1261816736 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Am[Wn[succ m == n] = {m}]
< 1261816781 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :do A and W commute?
< 1261816812 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no
< 1261816824 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :actually, this is not a proper quantifier
< 1261816829 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i shouldnt even say it like that
< 1261816834 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its a quantifier over rules
< 1261816839 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so i should just use variables
< 1261816852 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Wn[succ M == n] == {M}
< 1261816856 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric := {M} **
< 1261816857 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :this is stronger than TC I think
< 1261816949 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :you can immediately solve all diophantine equations
< 1261816955 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no, its not
< 1261816960 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :oh?
< 1261816961 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its just prolog
< 1261816969 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :I mean in theory
< 1261816970 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well
< 1261816973 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ok let me clarify
< 1261816975 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :it's like definabilify
< 1261816994 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its just quantified predicate calculus
< 1261817013 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :using what is essentially a prolog base interpreter
< 1261817024 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :as the algo to interpret it
< 1261817042 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :logics are "turing complete", algorithms that calculate logics are
< 1261817075 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the existential and universal quantifiers dont quantify over actual things, they're actually sort of more like assertions
< 1261817118 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :when you say Ex[F(x)] in this language, you're essentially specifying an axiom in a logic
< 1261817130 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the axiom being
< 1261817135 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::- Ex[F(x)].
< 1261817151 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :where :- is the logic turnstile operator
< 1261817156 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :oh okay
< 1261817164 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which says, "anything can prove that Ex[F(x)]"
< 1261817202 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which means you can use it whenever you want and its guaranteed to be true.
< 1261817203 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :I was thinking about it as a (paradoxically strong) language for computing sets
< 1261817233 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so really, in this "logic", using Ex[F(x)] in a truth conditional statement is always acceptable
< 1261817257 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :you know twelf?
< 1261817258 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :for instance, the expression [1] is equivalent to El[list(l) && p0(l,1) && p1(l,[])]
< 1261817263 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :twelf, no.
< 1261817267 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :damn
< 1261817279 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :I was going to ask, is it like twelf? :p
< 1261817282 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no
< 1261817304 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :this is me attempting to design a proglang that has the compositional semantics system of natural language.
< 1261817355 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :cool
< 1261817356 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :except in natural language, Ex[F(x)] is a normal truth-functional quantifier, not an assertion.
< 1261817372 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :I'm not totally sure what that means but I think my book gets into this later on
< 1261817372 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, maybe. :)
< 1261817390 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :what it means is that ive got some crazy shit in this language im designing :D
< 1261817436 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its got a transformational grammar
< 1261817461 0 :Asztal!n=asztal@host86-162-149-220.range86-162.btcentralplus.com JOIN :#esoteric
< 1261817472 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so that, to the extent that you can define generic functions, they will, almost inevitably, result in a rearrangement of the code
< 1261817569 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so that if you type lets say "1 == this 1", where "this 1" is the function \p.p(1)
< 1261817582 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :== doesnt take functions as its right hand argument
< 1261817601 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but the right hand argument does take Int -> Bool's
< 1261817620 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so you shift "this 1" to the front and turn the rest into a big lambda:
< 1261817639 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :this 1 (\x.1 == x)
< 1261817659 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and infact both of these are valid in the language
< 1261817683 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :infact, even "this 1 (1 ==) is valid in the language, in a kind of haskellish fashion
< 1261817696 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but the means of generating it are more interesting :P
< 1261817758 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :I don't really see what's going here: What is 'this' and is 1 just an arbitrary symbol
< 1261817770 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well
< 1261817774 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :1 is the value 1
< 1261817775 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :this isn't anaphora resolution is it?
< 1261817782 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :this is the function \x.\p.p(x)
< 1261818471 0 :poiuy_qwert!unknown@unknown.invalid QUIT :"This computer has gone to sleep"
< 1261818729 0 :neuDialect!n=IceChat7@ip-85-161-90-41.eurotel.cz JOIN :#esoteric
< 1261818924 0 :neuDialect!unknown@unknown.invalid PART #esoteric :?
< 1261819526 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :uorygl
< 1261819530 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :!
< 1261819537 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :check it out
< 1261819544 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :MoveHaskell
< 1261819549 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :MoveHaskell?
< 1261819567 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :a derivative of haskell with one very simple extra piece of functionality
< 1261819574 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :in an expression
< 1261819584 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f (g (... h))
< 1261819609 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which is equivalent to (f . g . ...) h
< 1261819622 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and where (f . g . ...) :: a -> b
< 1261819629 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and h is of type (a -> b) -> c
< 1261819649 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Are you sure you didn't mix those types up?
< 1261819651 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you can turn the expression into h (f . g . ...)
< 1261819653 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yes, im sure :)
< 1261819665 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the idea is
< 1261819669 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :in a type mismatch situation
< 1261819671 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :where the argument
< 1261819683 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :looks like it should be the function for some higher chain of args
< 1261819698 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :where the chain looks like it should be the argument of the actual argument
< 1261819703 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you can reverse them
< 1261819705 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :in the simplest case
< 1261819726 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Huh. That looks difficult to implement and not necessarily useful.
< 1261819728 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f g where f :: a -> b, g :: (a -> b) -> c
< 1261819734 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :this is a type mismatch
< 1261819738 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but it wouldnt be if it were g f
< 1261819740 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so make it g f
< 1261819767 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :thus you can do shit like, say
< 1261819806 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :"a" ++ "b" ++ "c" == which ["foo", "abc", "bar"]
< 1261819810 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :=> 1
< 1261819851 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :actually the simplest case is all you need to solve since the rest just pops out of it by iterated Move
< 1261819876 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which, i guess, is something like indexOf or whatever
< 1261819927 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or it functions like it, but is a wh word for ese of understanding
< 1261820062 0 :jpc!unknown@unknown.invalid QUIT :Read error: 60 (Operation timed out)
< 1261820517 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :hm
< 1261820533 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :my exxample was bad, because ++ is left associative and so ruins things
< 1261820535 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but
< 1261820591 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which ["foo", "abc", "bar"] == "abc" is just the same
< 1261820676 0 :ais523!n=ais523@unaffiliated/ais523 JOIN :#esoteric
< 1261820722 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i wanted to give an example where the shit before "which" couldnt be used wrapped in ()'s and have it work
< 1261820731 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :heh
< 1261820754 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :hi; which lang is this?
< 1261820757 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which ["foo"] == "f" ++ "b" ++ "c" i think exemplefies this
< 1261820761 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ais523: MoveHaskell!
< 1261820777 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :eso?
< 1261820782 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :slight mod to haskell.
< 1261820787 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :incredibly minor, infact.
< 1261820802 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :type mismatches of a certain sort are resolvable
< 1261820823 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :ah
< 1261820834 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so in this example
< 1261820850 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which ["foo"] :: String -> Int
< 1261820870 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but it cant find that as its next arg
< 1261820899 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so the interpreter replaces which ["foo"] with a temporary unbound variable x :: String
< 1261820917 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :giving x == ...
< 1261820972 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :actually sorry, which ["foo"] should really be more like (String -> Bool) -> Int
< 1261820994 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if it turns out that (x == ...) :: (String -> Bool) -> Int
< 1261821016 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the interp lambda binds x and feeds the result in as the argument to which ["foo"]
< 1261821114 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ais523: merp?
< 1261821162 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :(string -> bool) -> int is a weird typesig
< 1261821189 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well
< 1261821192 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the type sig is really
< 1261821199 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :weird?
< 1261821209 0 :FireFly!n=firefly@1-1-3-36a.tul.sth.bostream.se JOIN :#esoteric
< 1261821209 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which :: forall a. [a] -> (a -> Bool) -> Int
< 1261821222 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its essentially just firstIndexOf
< 1261821235 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :except with a test function instead of a value
< 1261821266 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :Data.List.findIndex :: (a -> Bool) -> [a] -> Maybe Int
< 1261821282 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you know what
< 1261821284 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :fuck you :|
< 1261821308 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ok so which = findIndex
< 1261821324 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :findIndex ["foo", "bar", "baz"] == "foo"
< 1261821334 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but thats ugly, hence the rename to which :P
< 1261821481 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its cool tho, because you can do craaazy shit
< 1261821487 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i think
< 1261821488 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :lol
< 1261821501 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :basically, anything where you'd normally do
< 1261821518 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f \x -> ...
< 1261821528 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you can turn that into ...f...
< 1261821546 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :assuming theres only one occurance of x in ...
< 1261821552 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :dunno about multiple occurances
< 1261821560 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :maybe thered be another rule for that :p
< 1261821568 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or a more general rule
< 1261821588 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :makes me think of shift/reset
< 1261821603 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f \x -> ...x...x...x... -> ...f... ... ...
< 1261821606 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or something
< 1261821611 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :I guess that's hinting toward some of cc shans notes on linguisticd
< 1261821662 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so you could end up doing: which xs f && g && h
< 1261821686 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :like say
< 1261821700 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which [1,2,3,4] > 1 && < 5 && odd
< 1261821771 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because there are missing vars in...
< 1261821786 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which _ [1,2,3,4] _ > 1 && _ < 5 && odd _
< 1261821810 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so it goes through building up \x -> x > 1 && x < 5 && odd x
< 1261821899 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :it also builds up \f -> which f [1,2,3,4]
< 1261821953 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :actually, im not sure how it'd do that, so lets pretend its which [1,2,3,4] f not which f [1,2,3,4]
< 1261821979 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ive never understood why they put the xs last in all these functions
< 1261821992 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :map f xs, foldr f z xs
< 1261821994 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so annoying
< 1261822030 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i guess maybe you have more curried (map f) and (foldr f z) than you do (map xs) and (foldr xs z)
< 1261823010 0 :MigoMipo!i=kvirc@95.209.17.173.bredband.tre.se JOIN :#esoteric
< 1261823013 0 :MigoMipo!unknown@unknown.invalid PRIVMSG #esoteric :join #jbopre
< 1261823021 0 :MigoMipo!unknown@unknown.invalid PRIVMSG #esoteric :Dammit!
< 1261823022 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :MigoMipo: missing slash
< 1261823038 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :morning
< 1261823046 0 :MigoMipo!unknown@unknown.invalid PRIVMSG #esoteric :Good morning!
< 1261823078 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ais523, see /msg
< 1261823193 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :I wonder how suspend to ram/disk interacts with cron jobs
< 1261823212 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :I mean, if some cron job is running right then
< 1261823297 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :also why is my dns so slow suddenly
< 1261823310 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :slow = takes several seconds to resolve anything
< 1261823368 0 :adam_d_!n=Adam@client-82-28-6-31.brhm.adsl.virginmedia.com JOIN :#esoteric
< 1261823382 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: it gets suspended and restarted just like any other process
< 1261823387 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm okay
< 1261823403 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ais523, what about missed cron jobs?
< 1261823408 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :if you see what I mean
< 1261823415 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :they never get run do they
< 1261823427 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :depends on which cron implementation you have
< 1261823436 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ais523, vixie-cron here
< 1261823446 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :I have anacron here, which runs them when it gets round to them
< 1261823454 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :as in, late rather than never
< 1261823460 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :but it's unusual in that respect
< 1261823460 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ais523, anacron needs normal cron to run it iirc
< 1261823470 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :and can only handle once per day stuff
< 1261823508 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :oh another cron question: how does cron handle with leap seconds.
< 1261823571 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :it would run on :59, surely, if that's what the seconds field said?
< 1261823577 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :and :00 if /that's/ what the second's field said?
< 1261823590 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :so, no differently from normal
< 1261823664 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm does cron do local time or utc?
< 1261823694 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :not sure offhand
< 1261823695 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :if local time, how does it handle switch to/from daylight saving
< 1261823703 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ACTION forgot which one leaps back an hour
< 1261823714 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :heh, all you need is a VM and an insane ntp server
< 1261823717 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :and you can find out by experiment
< 1261823805 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :I'm not sure where to find an insane ntp server ;P
< 1261823824 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :actually all I need is a VM without time syncing.
< 1261823830 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :so I can set it manually in there
< 1261823859 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :but I'm not THAT interested
< 1261823923 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :is it wrong that I always try to think up the most insane non-destructive solution to stuff, when I'm in here?
< 1261823924 0 :Pthing!unknown@unknown.invalid QUIT :Remote closed the connection
< 1261823926 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ais523, btw about that language on the wiki we talked about a few days ago, using two different interpreters. do you remember it's name?
< 1261823931 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :I have an idea for it you see
< 1261823942 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :Dupdog?
< 1261823945 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah yes thanks
< 1261823946 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :it isn't really two different interps
< 1261823951 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :it's just alternate commands are interpreted with different meanings
< 1261823968 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :as in, semantics of a command depend on whether an even or an odd number of commands were executed before it
< 1261823976 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :my idea is not to prove it tc by implementing something in it, my idea is to prove it not tc by implementing it in a sub-tc language
< 1261823980 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :wouldn't that be worth a try?
< 1261824004 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :yep
< 1261824011 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :it's one of the standard methods to prove something sub-tc
< 1261824016 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :now, what would be a good language for it
< 1261824016 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm
< 1261824046 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :if you want vapourware unreleased languages that I've never told the channel about, you could try ACK
< 1261824068 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :it's a vague attempt to make a language that's powerful enough to do pretty much anything sub-TC you'd want to do, but isn't TC
< 1261824068 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :befunge93 won't do, since I would need to store the source somewhere
< 1261824079 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :it clearly has infinite storage, is the issue
< 1261824090 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :and sub-TC things with infinite storage are kind-of rare
< 1261824101 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :is ACK such a language?
< 1261824107 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :you could try to implement it in Splinter, I suppose
< 1261824125 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: not exactly, basically you have to calculate how much storage you're going to use in advance
< 1261824125 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ACTION reads the splinter page
< 1261824132 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :and it's hard to see how to do that for dupdog
< 1261824162 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :(splinter's a push-down automaton)
< 1261824186 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm "push-down automaton". what exactly can it do that a FSM can't?
< 1261824189 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :PDAs are bad at duplicating unboundedly large values, though
< 1261824196 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: matching brackets is the most famous example
< 1261824201 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah
< 1261824206 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :a PDA can match to any depth of nesting, an FSM has to have some limit
< 1261824459 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :but PDA can't match a^nb^nc^n?
< 1261824548 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :this is correct.
< 1261824570 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, as a literal string? regex?
< 1261824580 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ACTION can't find any meaning in that line
< 1261824583 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :{,abc,aabbcc,aaabbbccc,...}
< 1261824588 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :interestingly, there are a small class of languages which can match a^n b^n c^n trivially, but cant match certain context free languages
< 1261824606 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, ah, how would you write that as PCRE?
< 1261824608 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :there is**
< 1261824635 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster might take me a few hours to figure that out :p
< 1261824657 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, I strongly suspects PCRE might be TC
< 1261824681 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :google books is such a tease
< 1261824694 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :it has recursion and what not after all
< 1261824966 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ais523, can you explain how that PDA proof works?
< 1261824985 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :it seems to be: N{N{N{}}I}Z{B{B{A{}}A{ZBAI}}A{O{ZBAO}I{ZBAI}N}}ZA\
< 1261824990 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :(followed by a newline)
< 1261825011 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :you could try stepping through it in an interpreter
< 1261825061 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :the basic idea is: you can compile a program that uses n splinters into a program that uses only a limited number by having a large object holding all of them, and a method to step through it
< 1261825073 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :and then store things on the call stack Underload-style
< 1261825099 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah
< 1261825170 0 :puzzlet!unknown@unknown.invalid QUIT :Read error: 60 (Operation timed out)
< 1261825177 0 :puzzlet!n=puzzlet@147.46.241.168 JOIN :#esoteric
< 1261825195 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :pda-splinter.pl: Lisp/Scheme program text
< 1261825201 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :file gone crazy heh
< 1261825428 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ais523, so what about implementing dupdog in that PDA language and then using the PDA->splinter compiler? would that be easier or harder than splinter directly do you think?
< 1261825438 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :no idea
< 1261825852 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :nah I can't figure it out
< 1261826039 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, can't figure what out?
< 1261826045 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :the regex
< 1261826053 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, ah
< 1261826058 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :well I suspect it is possible
< 1261826090 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ais523, meh, I can't think of a way to do it it either the PDA language or splinter directly
< 1261826102 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :I suspect dupdog can't be done by a PDA
< 1261826105 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :basically I guess the issue is understanding splinter
< 1261826108 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :although, ofc, that doesn't mean it's TC
< 1261826116 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ais523, what is there between a PDA and TC?
< 1261826176 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :LBA, but that only really works if you have a concept of input
< 1261826181 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :and a whole load of classes that don't have their own names
< 1261826185 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :because they don't come up very often
< 1261826193 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :(there are infinitely many classes, after all)
< 1261826248 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :http://www.stanford.edu/~laurik/fsmbook/examples/Einstein%27sPuzzle.html
< 1261826251 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :clever
< 1261826261 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ais523, but dupdog doesn't have stdin?
< 1261826282 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ais523, also which one is LBA?
< 1261826283 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: exactly, which is why LBA doesn't even make any sense wrt dupdog
< 1261826287 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :linear-bounded automaton
< 1261826291 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah
< 1261826299 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :no hits on the wiki
< 1261826340 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :oh why did searching for LBA not find http://esolangs.org/wiki/Linear_bounded_automaton
< 1261826341 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ais523, ^
< 1261826365 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :no redirect, you can add one if you like
< 1261826375 0 :ais523!unknown@unknown.invalid PRIVMSG #esoteric :mediawiki default search tends to rely a lot on human help
< 1261826381 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm
< 1261827625 0 :rodgort!unknown@unknown.invalid QUIT :Client Quit
< 1261827635 0 :rodgort!n=rodgort@li14-39.members.linode.com JOIN :#esoteric
< 1261828531 0 :|MigoMipo|!i=kvirc@95.209.203.251.bredband.tre.se JOIN :#esoteric
< 1261829440 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i just had an interesting idea
< 1261829496 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :protons are functions from electrons to 1
< 1261829573 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :e.g. p = \e -> 1 :: Electron -> Int
< 1261829599 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :concatenation of protons as in p0^p1 is sort of like fold:
< 1261829608 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :forked fold? who knows
< 1261829692 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :p0^p1 = \x -> \y -> p1 x + p0 y
< 1261829695 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or something like that
< 1261829745 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :hm..
< 1261829754 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well maybe it should track charge not charge-balances..
< 1261829835 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :hm hm
< 1261829843 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :obviously im sleep deprived :D
< 1261829863 0 :MigoMipo!unknown@unknown.invalid QUIT :Read error: 110 (Connection timed out)
< 1261830058 0 :soupdragon!unknown@unknown.invalid QUIT :"Leaving"
< 1261830396 0 :soupdragon!n=somebody@unaffiliated/fax JOIN :#esoteric
< 1261831034 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm
< 1261831041 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :hm!
< 1261831090 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, BNF?
< 1261831095 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :??
< 1261831099 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric : e.g. p = \e -> 1 :: Electron -> Int
< 1261831103 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no
< 1261831105 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :bad haskell
< 1261831107 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah
< 1261831122 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :well it would have been heavily modified bnf
< 1261831220 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::P
< 1261831224 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so not bnf
< 1261831237 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :and I don't know haskell
< 1261831243 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :been planning to learn it
< 1261831245 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :never had time
< 1261831256 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :and never found a nice tutorial that extended into the depths too
< 1261831263 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :heres haskell in a micosecond:
< 1261831271 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :math f(x) is haskell f x
< 1261831273 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :welcome to haskell
< 1261831275 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::P
< 1261831281 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, I'm pretty sure there is more than that
< 1261831286 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :the monads and what not
< 1261831294 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, also, what about f(x,y)
< 1261831299 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :shh! you'll wake the ehird!
< 1261831305 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f x y
< 1261831314 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm
< 1261831324 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :functions are all monadic in haskell
< 1261831326 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, then f(g(x),y)
< 1261831326 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :hardcore LC
< 1261831329 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :and f(g,x,y)
< 1261831332 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :how do they differ
< 1261831336 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f (g x) y
< 1261831339 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f g x y
< 1261831341 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :functions are all monadic in haskell ???
< 1261831341 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :okay that's lisp now
< 1261831349 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :ohh like J monadic
< 1261831351 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :yeah I got it
< 1261831352 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :nah, its just bracketted when need-be
< 1261831352 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :well not fully
< 1261831364 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no not all functions are monadic in haskell
< 1261831370 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :where did you get that idea
< 1261831374 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, is addition + x y
< 1261831375 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :too?
< 1261831378 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no
< 1261831380 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :meh
< 1261831381 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :sugared to x + y
< 1261831389 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but you can do it that way if you want: (+) x y
< 1261831394 0 :|MigoMipo|!unknown@unknown.invalid QUIT :"co'o rodo"
< 1261831395 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :"huh"
< 1261831402 0 :MigoMipo!i=kvirc@95.209.203.251.bredband.tre.se JOIN :#esoteric
< 1261831404 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :also what about all those type things and such
< 1261831416 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :see, haskell has sugar for operators right
< 1261831421 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :well okay
< 1261831422 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but operators are still just functions
< 1261831426 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so if you want to get the function
< 1261831431 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :stick it in parens to "call" it on nothing
< 1261831435 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :that is, return just the function
< 1261831438 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, but (+ x y) wouldn't work?
< 1261831441 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well now its the function, not the operator
< 1261831442 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no.
< 1261831445 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :right
< 1261831451 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :(+) x y
< 1261831458 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :((+) x y) ?
< 1261831460 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :sure.
< 1261831476 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :tho that might also be interpretable as a tuple with one elemtn
< 1261831485 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :im not sure how haskell disambiguates these things
< 1261831497 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, I suspect that by mixing the prefix and infix notations it is possible to create something that makes IOCCC seem quite sane and easy to read
< 1261831500 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :just a hunch
< 1261831521 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you have no clue
< 1261831524 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :it gets far far worse
< 1261831528 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ouch
< 1261831556 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, anyway, what is all the stuff about types and such.
< 1261831557 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :mostly because haskell can be highly pointsfree
< 1261831563 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :types
< 1261831563 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ok
< 1261831565 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :pointsfree?
< 1261831568 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yes
< 1261831571 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :tacit
< 1261831577 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ACTION googles
< 1261831580 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :like J again
< 1261831587 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f . g = \x.f (g x)
< 1261831587 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, which I don't know
< 1261831597 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :oh that's too bad J is fantastic
< 1261831603 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :I know erlang, lisp, C, bash, and a few other languages
< 1261831603 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: im really surprised
< 1261831606 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :youve been here longer than me
< 1261831609 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :(like python)
< 1261831610 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and i know of J
< 1261831611 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :cmon
< 1261831614 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :dont be a slacker
< 1261831616 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :anyway
< 1261831619 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so with haskell
< 1261831621 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :lets say
< 1261831624 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f x = x + 1
< 1261831630 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :right
< 1261831632 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :then f has the type Int -> Int
< 1261831633 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :that seems easy enough
< 1261831638 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, makes sense
< 1261831639 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :well
< 1261831641 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :wait no
< 1261831645 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, why can't x be a float
< 1261831654 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :or any other numeric type
< 1261831660 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, 1 has the type Int
< 1261831663 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :1.0 has the type Float
< 1261831664 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i think
< 1261831665 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so..
< 1261831668 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm
< 1261831669 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :okay
< 1261831671 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you have to convert i guess
< 1261831677 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :anyway
< 1261831686 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f x = x + 1 is desugard to f = \x -> x + 1
< 1261831696 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :mhm
< 1261831700 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and so the type looks like whats on either side
< 1261831702 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :x is an Int
< 1261831707 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :what does the \ signify?
< 1261831708 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and (x + 1) is an Int too
< 1261831722 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f x y = x + y is desugared to \x -> \y -> x + 1
< 1261831730 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :er
< 1261831731 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :x + y**
< 1261831735 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which is Int -> (Int -> Int)
< 1261831745 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :err
< 1261831749 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :since x is an Int and \y -> x + 1 is an Int -> Int
< 1261831790 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :what exactly do you mean by -> here?
< 1261831803 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :X -> Y ~ "Take and X and return a Y"
< 1261831811 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :right
< 1261831822 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if this were an untyped lambda calculus
< 1261831830 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :\x -> \y -> x + y is trivially obvious, right
< 1261831833 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :apply it to the number 2
< 1261831834 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and you get
< 1261831835 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :then why isn't f x y = x + y "takes 2 integers and returns one"
< 1261831838 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :\y -> 2 + y
< 1261831844 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm
< 1261831852 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :why, because haskell is lambda calculus.
< 1261831854 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :with types.
< 1261831855 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and fun.
< 1261831856 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, so it returns a lambda that takes the other parameter?
< 1261831860 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yes
< 1261831869 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :okay
< 1261831870 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :hence the following is completely valid haskell:
< 1261831871 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f 2
< 1261831876 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f 2 == \y -> 2 + y
< 1261831889 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :so it returns an "add 2" function
< 1261831891 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :fun
< 1261831895 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :sure.
< 1261831922 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, so what about functions/operators like + - and such that can take various types
< 1261831931 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :or does haskell have separate + operator for ints and floats?
< 1261831937 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :have a*
< 1261831943 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, so theres type polymorphism right
< 1261831946 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :for instance
< 1261831948 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :uhu
< 1261831951 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you might have the function
< 1261831959 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f x = [x]
< 1261831963 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm
< 1261831964 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :now, lists are typed in haskell
< 1261831965 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but
< 1261831969 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :surprise surprise
< 1261831972 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :[] being list? right
< 1261831976 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :lists are polymorphically typed
< 1261831979 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so theyre like
< 1261831985 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :lists of whatever type you give it
< 1261831992 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so f x is also polymorphic
< 1261831999 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :what is its type specifically?
< 1261832001 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, like list of foo? well okay
< 1261832006 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f :: forall a. a -> [a]
< 1261832007 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :where foo can vary
< 1261832022 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :where [a] is the sugar for list of a's
< 1261832028 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, what does the "a. a" bit mean.
< 1261832033 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :or rather
< 1261832036 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :what does the . there mean
< 1261832037 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :a. a doesnt mean anything :P
< 1261832045 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :forall a. a -> [a]
< 1261832045 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :means
< 1261832046 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, okay how should one parse that bit then
< 1261832067 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :for all types a, f can be a -> [a]
< 1261832086 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so if you give f an int
< 1261832094 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f is behaving like its of type Int -> [Int]
< 1261832104 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :give it a string and its behaving like its of type String -> [String]
< 1261832105 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :etc
< 1261832106 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :that is
< 1261832116 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :for ALL types a, f can behave like a -> [a]
< 1261832122 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah
< 1261832123 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or, f :: forall a. a -> [a]
< 1261832141 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, so this is not exactly the same as predicate logic ∀ then?
< 1261832148 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well
< 1261832151 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yes and no
< 1261832159 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if you're doing a typed lambda calculus
< 1261832163 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :same procnounciation
< 1261832164 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :this is a quantifier over types
< 1261832172 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :rather than a quantifier over values
< 1261832177 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :String -> [String] <-- is that a list of 1 or more strings?
< 1261832181 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :or 0 or more strings
< 1261832186 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :0-or-more
< 1261832188 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah
< 1261832192 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the list [] is of type
< 1261832196 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :forall a. a -> [a]
< 1261832210 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :[a] just means "a list of a's"
< 1261832217 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and a list of no a's is still a list of a's
< 1261832219 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :anyway
< 1261832225 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :well [] being of any type makes sense. After all the empty set is a subset of every other set
< 1261832234 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so, as for polymorphisms
< 1261832243 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :in general
< 1261832256 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i think you can have multiple functions with the same name
< 1261832263 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so long as they have different type signatures
< 1261832266 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :e.g. you could define
< 1261832268 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah
< 1261832286 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :(+) :: Int -> Int -> Int
< 1261832287 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and also
< 1261832292 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :(+) :: Float -> Float -> Float
< 1261832293 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and so on
< 1261832295 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, couldn't there be some confusion about which one to use in certain cases? If there are implicit casts available in haskell?
< 1261832302 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :if there isn't I can't imagine it being an issue
< 1261832308 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no, i dont think there are implicit casts, so
< 1261832327 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :oh, there are. hah.
< 1261832330 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :oh?
< 1261832334 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, the compiler is smart
< 1261832344 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :it rounds down to the most applicable type
< 1261832345 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so
< 1261832373 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :infact, it seems that haskell has a generic type class Num
< 1261832376 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :I can still imagining that being an issue sometimes
< 1261832383 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and Int and Float are both Nums
< 1261832395 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, so the types form a hierarchy? sensible
< 1261832408 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and (+) is required to be of type (Num a) => a -> a -> a
< 1261832420 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :okay
< 1261832429 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :where (Num a) => ... just means sort of
< 1261832440 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :for all types a, which are of the typeclass Num, a -> a -> a
< 1261832457 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, btw, couldn't you pass a tuple or such to make a function take two arguments (instead of returning a lambda)
< 1261832470 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :sure
< 1261832491 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :then its a 1-arg function that requires a 2-tuple
< 1261832496 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, also that leaves some interesting related questions: how you build and take apart tuples
< 1261832497 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and it has pattern matching over the tuple
< 1261832498 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so like
< 1261832502 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f (x,y) = x + y
< 1261832503 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :as in, how do I get the second member of a tuple
< 1261832505 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :aha
< 1261832506 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :this is fine
< 1261832513 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but you cant then do f 1
< 1261832517 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because 1 is not a 2-tuple
< 1261832520 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, so similar to pattern matching?
< 1261832530 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :(in the erlang sense of that)
< 1261832531 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its pattern matched, yes.
< 1261832536 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :right
< 1261832541 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but shallowly
< 1261832545 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :oh?
< 1261832548 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :how do you mean
< 1261832554 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so you can, for instance, do
< 1261832566 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :first x:xs = x
< 1261832577 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :first x:xs would mean?
< 1261832584 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, x:xs is cons
< 1261832586 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah
< 1261832592 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :a cons pair
< 1261832595 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its sugar for roughly
< 1261832597 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Cons x xs
< 1261832602 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, and what are the car and cdr functions?
< 1261832616 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :where Cons is a data constructor
< 1261832626 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, I know scheme :P
< 1261832633 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no no no
< 1261832636 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i dont mean its a cons function
< 1261832641 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :oh=
< 1261832642 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its a special thing
< 1261832644 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :s/=/?/
< 1261832645 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :a data constructor
< 1261832651 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :like
< 1261832660 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, is it like erlang's [H|T] then?
< 1261832662 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :it forms the basis of the ASTs in haskell
< 1261832665 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yea sure
< 1261832672 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :lets pretend its that
< 1261832673 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its not, but
< 1261832673 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, on the left or the right side of = ?
< 1261832675 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah
< 1261832679 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :also
< 1261832685 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :people dont usually use car and cdr
< 1261832693 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because they can just match them out
< 1261832702 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so you'd never define first = car
< 1261832704 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you'd just do
< 1261832705 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :like erlang's [H|T] then for head/tail
< 1261832713 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :first x:xs = x
< 1261832720 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :right
< 1261832738 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, xs being a variable name that isn't used I guess?
< 1261832747 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :it would be the cdr I imagine?
< 1261832752 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well
< 1261832753 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yes
< 1261832761 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i mean
< 1261832764 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you can just like
< 1261832767 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :type 1 : []
< 1261832768 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :doesn't the compiler warn about unused variable then?
< 1261832772 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and this conses together 1 and []
< 1261832775 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :to give you [1]
< 1261832788 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :1 : 2 : [] = 1 : [2] = [1,2]
< 1261832793 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :type being a keyword to define a type?
< 1261832802 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no no no
< 1261832806 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :oh
< 1261832807 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i mean if you type 1 : []
< 1261832808 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah
< 1261832816 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :right, it wasn't part of the code, heh sorry
< 1261832828 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::P
< 1261832835 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ill use > on newlines
< 1261832839 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :since lambdabot isnt here
< 1261832842 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm
< 1261832844 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :> 1 : []
< 1261832845 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :[1]
< 1261832856 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :> 1 : 2 : []
< 1261832857 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :[1,2]
< 1261832863 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :right
< 1261832881 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :> let first x:xs = x in first [1,2,3]
< 1261832882 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :1
< 1261832893 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :> let rest x:xs = xs in rest [1,2,3]
< 1261832895 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :[2,3]
< 1261832916 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, so 1 : 2 : [] is (cons 1 (cons 2 '())) ?
< 1261832920 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :this is because [1,2,3] is really really just sugar for 1:2:[]
< 1261832926 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :sure
< 1261832932 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :sensible
< 1261832934 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :er
< 1261832936 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :1:2:3:[]
< 1261832942 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :(if you are insisting on infix ;P)
< 1261832944 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :: being right associative
< 1261832954 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, yes
< 1261832965 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if we were using prefixing:
< 1261832983 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :[1,2,3] is sugar for (:) 1 ((:) 2 ((:) 3 []))
< 1261832985 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::P
< 1261832986 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :if you are going to prefix you might as well use lisp instead ;P
< 1261832993 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and if we were using the List monad:
< 1261833000 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :[1,2,3] is sugar for uh
< 1261833008 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :List 1 (List 2 (List 3 []))
< 1261833011 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah now we come to "monad"... now what on earth is that exactly?
< 1261833016 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :noone knows
< 1261833022 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no im kidding
< 1261833027 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Monad is a type class
< 1261833037 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :like Int or Num?
< 1261833041 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no
< 1261833044 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Num
< 1261833050 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Int is an instance of the type class Num
< 1261833052 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :aha
< 1261833067 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so as an instance of the Monad type class
< 1261833070 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, so you can only have 2 layers then? type class and type?
< 1261833076 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :or can type classes inherit each other
< 1261833079 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i think so
< 1261833086 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i think you only get types and type classes
< 1261833088 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah
< 1261833089 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :right
< 1261833095 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and you just multi-class a type
< 1261833099 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :mhm
< 1261833106 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :okay so monad is a type class
< 1261833107 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :right
< 1261833116 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :on an instance of Monad you can (must?) have defined certain functions
< 1261833126 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :makes sense.
< 1261833129 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i think the three are >>=, return, and ... maybe thats it?
< 1261833147 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :... being an operator??
< 1261833154 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no no sorry :p
< 1261833155 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :or function I guess
< 1261833158 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :>>= and return
< 1261833160 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah
< 1261833166 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :are the only functions.
< 1261833176 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :and those do what
< 1261833189 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :(and where does IO and state come into this)
< 1261833196 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, theyre, by convention, required to follow certain rules
< 1261833198 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :namely
< 1261833209 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :(return a) >> k == k a
< 1261833218 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :m >>= return == m
< 1261833222 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hrrm >> ?
< 1261833232 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :xs >>= (return . f) == fmap f xs
< 1261833248 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :x >>= (\x -> (k x) >>= h) == (m >>= k) >>= h
< 1261833264 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :those are the facts that must hold of >>= and return
< 1261833281 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :when i say must, i mean "by convention of what a monad is"
< 1261833291 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you can violate them, but dont expect your code to behave monadically
< 1261833291 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, writing those in English would help, I'm not very used to the multitude of use of punctuation that haskell uses (possibly even exceeding perl at that!)
< 1261833299 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :er
< 1261833301 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well look
< 1261833305 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :>>= is just an operator right
< 1261833308 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :right
< 1261833310 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :like + or %
< 1261833318 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :sure, I'm okay with that
< 1261833322 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so (return a) >>= k == k a
< 1261833343 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :means that (return a) >>= k must return the same value as k a
< 1261833347 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm okay
< 1261833354 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :so the >> instead of >>= was a typo?
< 1261833359 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yes, obviously.
< 1261833360 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::P
< 1261833364 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :that explains a bit
< 1261833364 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :. is the compose operator
< 1261833366 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :defined as
< 1261833376 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, okay, I'm more used to seeing the compose operator as a mid dot
< 1261833378 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :also which way is it
< 1261833379 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :f . g = \x -> f (g x)
< 1261833383 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah
< 1261833392 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :. IS a mid dot
< 1261833395 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :just ascii-ish :P
< 1261833402 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :I'm pretty sure I have seem f g mean g(f(x)) somewhere
< 1261833408 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yes
< 1261833409 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :in math
< 1261833414 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but haskell isnt APL
< 1261833416 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so.
< 1261833420 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, yes, which is where I have seen the mid dot!
< 1261833442 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :f o g in SML
< 1261833447 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :ring
< 1261833453 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so those are the monad laws
< 1261833467 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and thats what defines a monad
< 1261833468 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, what is fmap?
< 1261833478 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :a functor map
< 1261833486 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :uh you lost me there
< 1261833500 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :you can define fmap usint >>= and return
< 1261833500 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :is it related to maping a lambda over a list in any way?
< 1261833513 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :if m = [] then it is the list map
< 1261833525 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm okay
< 1261833525 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :fmap is i think probably somethat you can think of as like
< 1261833538 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :a monad-specific definable version of map
< 1261833545 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :a generic map over lists as well as other types?
< 1261833566 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, are monads all Functors? they are right?
< 1261833581 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :yes
< 1261833590 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :then where does state and IO come into monads?
< 1261833594 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so, monads are all Functors, Functor being another type class
< 1261833606 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and so in order to be a Monad you also have to be a Functor which means you have to have fmap defined.
< 1261833610 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :yes, another (equivalent) definition of monad is Functor with join and return
< 1261833631 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which obeys its own set of laws
< 1261833637 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm
< 1261833642 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :namely
< 1261833658 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :fmap id x = x
< 1261833658 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and
< 1261833679 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :fmap (f . g) x = fmap f (fmap g x)
< 1261833704 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :IO and state who knows.
< 1261833734 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm
< 1261833736 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i mean, the way you do it, afaik, is that like
< 1261833756 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :fmap takes a lambda and whatever it is to map over?
< 1261833763 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :or how do you mean
< 1261833766 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if you just call into existence an IO monad, itll sort of be the same monad every time.
< 1261833777 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but if you pipe an IO monad through some magic functions
< 1261833779 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :fmap f m = do x <- m ; return (f x)
< 1261833783 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you get new IO monads
< 1261833790 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, sounds like black compiler magic to me...
< 1261833793 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :it is
< 1261833798 0 :MigoMipo!unknown@unknown.invalid QUIT :"co'o rodo"
< 1261833806 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the idea is basically that the monads you're getting back are not the SAME monad you put in
< 1261833812 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and therefore can be different
< 1261833816 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, and why is that important?
< 1261833828 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, because it provides the illusion of purity
< 1261833836 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :mhm
< 1261833844 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :suppose you just called forth an IO monad from nothing
< 1261833847 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and assigned it to x
< 1261833857 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and then you did some shit with it, printing a line to the screen
< 1261833858 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, how is this better than just making most of your code pure and having a tiny bit with all the unpure stuff
< 1261833865 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :thus getting back a new monad that you assign to y
< 1261833869 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :like you commonly do in scheme or erlang for example
< 1261833895 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if you then tried to print to the screen again using x, i think nothing would happen on screen
< 1261833903 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, hm okay
< 1261833904 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :(im not entirely sure on this; i dont do this IO shit in haskell :P)
< 1261833911 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :instead you'd have to use the monad stored in y
< 1261833922 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, how do you then get the result from your computation back? ;P
< 1261833928 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and you'd keep chaining together the monads you get back from previous IO function calls
< 1261833930 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :always using the REPL?
< 1261833940 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :right so input is sort of the same, right
< 1261833947 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :mhm
< 1261833955 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if you ask the monad stored in y, now, for an input
< 1261833968 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :itll give you back a string paired with a new IO monad i think
< 1261833972 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :okay
< 1261833975 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the new monad you can do shit with however you want
< 1261833981 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if you ask y for input AGAIN
< 1261833986 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you get back the same string-monad pair as before
< 1261833995 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :it doesnt go ask the user for input again
< 1261834001 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, I sure hope haskell's GC is good then
< 1261834014 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :im fairly certain that its spot on
< 1261834016 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :since it sounds like reading a file would take an awful lot of memory
< 1261834033 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :nah, i think read ops are compiler-internally single operations
< 1261834034 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :well, hoepfully it shares the string read in question
< 1261834040 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you get back a monad and the content string
< 1261834060 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :like i said, im not entirely clear on this IO stuff
< 1261834063 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but
< 1261834064 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :right
< 1261834070 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :what about the state monad then?
< 1261834085 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :state is more black magic
< 1261834094 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :even more than IO? hard to imagine
< 1261834102 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :state isn't black magic at all :(
< 1261834104 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i think its vaguely like a monad that has hash-like magic
< 1261834109 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :oh?
< 1261834113 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :ST is magic, State isn't.
< 1261834115 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :ST vs State
< 1261834123 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Asztal, what is ST and what is State?
< 1261834124 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so that when you "assign" you're taking a var-binding hash, and deriving a new hash with the "bound" var changed
< 1261834139 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :e.g. you're going from, say, { "x" => 1 } to { "x" => 2 }
< 1261834145 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm oaky
< 1261834146 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :in a purely functional fashion
< 1261834146 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :okay*
< 1261834151 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, what is {} here?
< 1261834156 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :you haven't used that above
< 1261834159 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :nothing, im just making shit up
< 1261834162 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah
< 1261834175 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :ST means State Thread, it kind of ensures that there's only one "world state" in existence at any time, so you can mutate the world as you please
< 1261834180 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :it looked slightly python-dict-ish
< 1261834196 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its supposed to be ruby-esque but whatever
< 1261834215 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, well not knowing ruby I guess python was the next best I could manage ;P
< 1261834217 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i dont know how these magic monads are implemented so, yeah.
< 1261834230 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :IO and ST are implemented in a very similar way :)
< 1261834237 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm
< 1261834257 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :ST is elite
< 1261834272 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Asztal, why "thread"?
< 1261834294 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :does it actually act like a erlang style of state process. (being a common idiom)
< 1261834297 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :IO is sort of a special instance of ST where the state you're manipulating is... the real world!
< 1261834298 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because its a state monad that threads through your whole program! :P
< 1261834310 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah so not thread as in separate process then?
< 1261834317 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i dont know :P
< 1261834320 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :probably not
< 1261834320 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :not a thread in that sense, no.
< 1261834323 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :right
< 1261834326 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i dont think haskell has explicit threading
< 1261834351 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because its lazy and functional, you can spin off arbitrarily many threads in your compiled program
< 1261834357 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and im pretty sure it works fine
< 1261834363 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :because using a separate process in erlang is a common idiom to keep the state. basically you send/receive messages to/from that process to access the state
< 1261834366 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :parallelize the shit out of everything
< 1261834373 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :and that one just does a tail recursive loop
< 1261834377 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :with it's state as a parameter
< 1261834386 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :nothing needs to be explicit except, i think, in your compile params
< 1261834404 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm
< 1261834412 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, well, one issue is where to thread
< 1261834430 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :I guess the compiler is smart enough to figure out where it is an overhead and where it isn't?
< 1261834480 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :sure
< 1261834489 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :a heuristic I can't imagine as being 100% fool-proof ;P
< 1261834499 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :guys
< 1261834500 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :where is lambdabot
< 1261834502 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :The expression (x `par` y) sparks the evaluation of x (to weak head normal form) and returns y. Sparks are queued for execution in FIFO order, but are not executed immediately. If the runtime detects that there is an idle CPU, then it may convert a spark into a real thread, and run the new thread on the idle CPU. In this way the available parallelism is spread amongst the real CPUs.
< 1261834503 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :we need lambdabot
< 1261834517 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :http://www.haskell.org/ghc/docs/latest/html/users_guide/lang-parallel.html
< 1261834533 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Asztal, ah interesting
< 1261834537 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well there you go.
< 1261834544 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :wheres lambdabot
< 1261834545 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::|
< 1261834553 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, I have ghci in a window here
< 1261834555 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :no issue
< 1261834602 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well still
< 1261834613 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, does haskell have any sort of macros? In the meaning of lisp macros I mean
< 1261834620 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i dont think so
< 1261834624 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ah okay
< 1261834637 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :it's not quite as cool as lisp, but it does have template haskell
< 1261834651 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm okay
< 1261834655 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :theres some crazy shit that people do with haskell tho
< 1261834660 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Asztal, nothing like C++ templates I hope?
< 1261834661 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :somehow they get reactive programming
< 1261834664 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which is like
< 1261834669 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :the epitome of anti-laziness
< 1261834672 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :programming that bites back?
< 1261834678 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :;P
< 1261834754 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, so how would you do something like a memoizing Fibonacci function in haskell?
< 1261834773 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :that is, one which counds up, not down, and reuses the calculations
< 1261834781 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :so it doesn't have to calculate everything a lot of times
< 1261834785 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no clue
< 1261834789 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i mean
< 1261834794 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :you could probably do something stupid like
< 1261834798 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :fib n memo = ...
< 1261834805 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and just carry your memos with you
< 1261834826 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :maybe you'd do a memoized-fib monad
< 1261834838 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :MemFib Int [Int]
< 1261834853 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and use do notation to peel it open
< 1261834855 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, in scheme I would do it as a tail recursive function
< 1261834874 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :you don't get TCO in haskell
< 1261834889 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :do (n, memo) <- mfib (5, [])
< 1261834892 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :or something
< 1261834894 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :http://www.haskell.org/haskellwiki/Memoization#Memoization_with_recursion :P
< 1261834896 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, oh? how do you implement something like a main loop then?
< 1261834916 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :main = do ...
< 1261834919 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :oops
< 1261834921 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :main = do ... ; main
< 1261834929 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, looks like a tail call?
< 1261834937 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :yeah but it's not
< 1261834944 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Asztal's memoized fib there looks like magic
< 1261834946 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :then what is it
< 1261834946 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :because it is
< 1261834949 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :haskell is magic.
< 1261834965 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :I can explain the memoization
< 1261834968 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :if you want
< 1261834974 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, to me? or augur ?
< 1261834978 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :anyone
< 1261834995 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its the magic of infinite lists and such
< 1261835004 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, the one Asztal linked seems fairly easy to understand, apart from the !! bit
< 1261835008 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :which I have no idea what it means
< 1261835038 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :"list !! i" picks the i'th element from the list.
< 1261835039 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :actually, what its doing is defining an infinite list thats calculated over some other infinite list
< 1261835042 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm okay
< 1261835051 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and by virtue of it being defined ones, and in terms of itself
< 1261835054 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :huh
< 1261835078 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :when you go to plug some elements off the list, it just traces back the list, building it up as far as it needs to
< 1261835095 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and, since it IS the same list, it only ever gets built up once
< 1261835097 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :I have to say that the variant I thought of in scheme is a lot more sensible, just tail recursion and pass the value of the last calculations along
< 1261835109 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :and by built i mean in the interpreter when it tries to evaluate it
< 1261835121 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :yes, thats what you could do in haskell too
< 1261835134 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but then you have to explicitly carry this around
< 1261835139 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :well okay
< 1261835147 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :what the one here doesnt let you do tho
< 1261835151 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :is memoize across calls to fib
< 1261835154 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so if you did like
< 1261835156 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :well okay
< 1261835157 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :fib 1000000
< 1261835159 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :then did it again
< 1261835164 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :it would take the same amount of time
< 1261835173 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, then I would write it in another way indeed
< 1261835182 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :if I needed that
< 1261835182 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :whereas if you were explicitely carrying it around, you could do like
< 1261835204 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, you could use the ST monad to store it somehow? :D
< 1261835206 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :let (x, memo) = fib 1000000 [] in fib 1000000 memo
< 1261835215 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: probably
< 1261835219 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :state monad
< 1261835220 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i dunno
< 1261835224 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :its magic!
< 1261835227 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :right
< 1261835238 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :so what is this infinte list stuff about.
< 1261835241 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but you'd still need the explicit stuff i think
< 1261835244 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :infinite lists!
< 1261835248 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well ok so haskell is lazy, right
< 1261835255 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :it doesnt evaluate it unless it needs to
< 1261835263 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so lets do the classic infinite list
< 1261835264 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :well okay
< 1261835266 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ones = 1:ones
< 1261835279 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm
< 1261835282 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :this is fine, because haskell doesnt need to evaluate ones when DEFINING ones
< 1261835287 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :it doesnt need to evaluate anything, infact
< 1261835291 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :of course
< 1261835298 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :I have no problems with that idea at all
< 1261835302 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :so that is all it is then?
< 1261835313 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :or can you do more interesting stuff with it?
< 1261835313 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :tho i think itll check for scopes
< 1261835321 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :well, you can do interesting stuff, but it all comes down to that
< 1261835328 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :if you do first ones
< 1261835339 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :it doesnt need to evaluate ones beyond its first value
< 1261835350 0 :MizardX-!n=MizardX@unaffiliated/mizardx JOIN :#esoteric
< 1261835358 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :augur, what about using it to calculate 1/2+1/4+1/8+1/16+...
< 1261835360 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :when you do third ones it then goes through and evals what it needs to eval to get there
< 1261835378 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ok so that is probably something like lets see
< 1261835390 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :doesn't that go to 1 when the number of elements summed goes to infinity iirc?
< 1261835393 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster that's kind of impossible
< 1261835398 0 :MizardX!unknown@unknown.invalid QUIT :Read error: 104 (Connection reset by peer)
< 1261835407 0 :MizardX-!unknown@unknown.invalid NICK :MizardX
< 1261835418 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, not in math. I think the limit when n goes towards infinite is 1. Unless I misremember
< 1261835428 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster, ??
< 1261835433 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :in haskell
< 1261835440 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i want to say
< 1261835441 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, I meant http://upload.wikimedia.org/math/e/c/2/ec2190a57b685add5a4e43c3ecfeed94.png
< 1261835443 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :tha the defintionis
< 1261835470 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, it would be cool if you could use haskell to do that kind of stuff
< 1261835471 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :suppose you do sum [1/2,1/4,1/8,..]
< 1261835485 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :but I guess you are better off with mathematica or some other CAS
< 1261835485 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :halves = 1 : map (\x -> x/2) (drop 1 halves)
< 1261835491 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :but i killed ghci doing that
< 1261835492 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :so
< 1261835496 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :there's no way + can know that the 100th element of that sequence isn't suddenly 62662
< 1261835504 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, true.
< 1261835517 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :that will get you [1,1/2,1/4,...]
< 1261835544 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :then you'd just take however many out you want for precision and fold them down
< 1261835550 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :i guess you could also do this the smarter way
< 1261835551 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :which is
< 1261835553 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :if you defined it in the same way as mathematica you could compute it
< 1261835572 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :(as a series, rather than an infinite sum)
< 1261835578 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :[x ** n : n <- [0..]]
< 1261835616 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :augur: Lose the drop 1
< 1261835620 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :whoops, |
< 1261835625 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant: but it NEEDS drop 1!
< 1261835630 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :no it doesnt
< 1261835631 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric ::D
< 1261835635 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :Only for the infinite loop :-P
< 1261835639 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :im a silly person i am
< 1261835683 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :huh?
< 1261835686 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :what does the drop 1 mean?
< 1261835695 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :drop 1 x:xs = xs
< 1261835703 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, atm I'm trying to work out what it would be in mathematica
< 1261835706 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :drop n x:xs = drop n-1 xs
< 1261835727 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm it gives me (pi^2)/6
< 1261835775 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster, I mean if you represent it symbolically, like Sigma (\n -> Div 1 (Exp 2 n)) then you could write an algorithm to try and solve sums (like mathematica)
< 1261835789 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, right
< 1261835802 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, what was that about 1/(1+1/(1+1/...
< 1261835813 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :huh?
< 1261835818 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :or something like that
< 1261835823 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :*tries to remember the series*
< 1261835830 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :that ones golden ratio
< 1261835830 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :it was some rather neat series of infinite divisions
< 1261835837 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :but that's not what I was talking about
< 1261835842 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, well true
< 1261835853 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :I was just jumping to a different thought
< 1261835869 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :anyway it wasn't the golden ratio I meant
< 1261835872 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :phi = 1/(1+phi) also diverges in haskell :P
< 1261835878 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, the point was that it added up to exactly 2
< 1261835883 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :so it must have been a different one
< 1261835896 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :ok im going to sleep for a little bite guys
< 1261835896 0 :augur!unknown@unknown.invalid PRIVMSG #esoteric :afk
< 1261835900 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :it was a continued fraction of some sort
< 1261836151 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :(an infinite one at that)
< 1261836346 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :oh wait it was not
< 1261836367 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :it was 1 + 1/2 + 1/4 + 1/8 + 1/16 + 1/32
< 1261836370 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :and so on
< 1261836437 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, that adds up to 2
< 1261836443 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :yeah
< 1261836447 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :0.1111111... = 1
< 1261836449 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :er
< 1261836452 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :1.1111111... = 10
< 1261836459 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :err?
< 1261836464 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :binary
< 1261836467 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, oh right
< 1261836478 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, as a floating point number?
< 1261836486 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :a real number
< 1261836497 0 :coppro!unknown@unknown.invalid QUIT :Read error: 110 (Connection timed out)
< 1261836504 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :how do you mean it would be stored then
< 1261836515 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :if decimal 1.11111... is 10 in binary?
< 1261836538 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :oh you mean binary for both?
< 1261836541 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :right yeah
< 1261836586 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :anyway that sum was Sum[1/2^i, {i, 0, Infinity}] I think
< 1261836605 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :is that mathematica code for it?
< 1261836617 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, well yes for 1 + 1/2 + 1/4 + 1/8 + 1/16 + 1/32 + ...
< 1261836645 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :cool does it compute it to 2?
< 1261836654 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, it does
< 1261836667 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :that's pretty cool I wonder what algorithm it uses
< 1261836684 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, in latex \sum _{i=0}^{\infty } \frac{1}{2^i} I think
< 1261836694 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :well mathematica claims it is
< 1261836696 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :with convert to latex
< 1261837336 0 :BeholdMyGlory!n=behold@d83-183-183-70.cust.tele2.se JOIN :#esoteric
< 1261838707 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, well that is not public for mathematica mostly iirc
< 1261838716 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric ::(
< 1261838717 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :ACTION tests with maxima
< 1261838768 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, maxima manages it too
< 1261838770 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :and that is open source
< 1261838798 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :sum(1/(2^k), k, 0, inf), simpsum;
< 1261838801 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :gives 2
< 1261838807 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon, so go look at that
< 1261839793 0 :ais523!unknown@unknown.invalid QUIT :Connection timed out
< 1261840776 0 :ais523!n=ais523@unaffiliated/ais523 JOIN :#esoteric
< 1261841731 0 :soupdragon!unknown@unknown.invalid QUIT :"Leaving"
< 1261842274 0 :FireFly!unknown@unknown.invalid QUIT :Connection timed out
< 1261842342 0 :FireFly!n=firefly@1-1-3-36a.tul.sth.bostream.se JOIN :#esoteric
< 1261846024 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Gregor, btw, that "linux binaries on OS X" idea with your elfloader, did you do any work of that?
< 1261846068 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :s/of/on/
< 1261846809 0 :adam_d_!unknown@unknown.invalid NICK :adam_d
< 1261849432 0 :FireFly!unknown@unknown.invalid QUIT :Read error: 60 (Operation timed out)
< 1261850374 0 :FireFly!n=firefly@1-1-3-36a.tul.sth.bostream.se JOIN :#esoteric
< 1261853395 0 :jpc1!n=jw@unaffiliated/javawizard2539 JOIN :#esoteric
< 1261855153 0 :bsmntbombdood!unknown@unknown.invalid NICK :bsmntbombgirl
< 1261855943 0 :Desmo!n=Desmo@host155-97-dynamic.1-79-r.retail.telecomitalia.it JOIN :#esoteric
< 1261856318 0 :ais523!unknown@unknown.invalid QUIT :Remote closed the connection
< 1261856337 0 :Desmo!unknown@unknown.invalid PART #esoteric :?
< 1261861610 0 :oerjan!n=oerjan@hagbart.nvg.ntnu.no JOIN :#esoteric
< 1261863179 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm interesting stuff happens when you delete part of the stuff while tar is still extracting:
< 1261863204 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :tar: linux-2.6.32.2/arch/microblaze: Function "stat" failed: File or directory not found
< 1261863220 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :I was trying to save some space by deleting all the arches I didn't need
< 1261863446 0 :coppro!n=coppro@unaffiliated/coppro JOIN :#esoteric
< 1261863470 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :Presumably it was extracting into that directory, so of course it expects it to still exist.
< 1261865454 0 :jpc1!unknown@unknown.invalid NICK :jpc
< 1261866627 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :ACTION goes to see if Gregor has any simpler opuses.
< 1261866788 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Er, opera.
< 1261866888 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Well, Opus 10 sounds simpler, but it's less interesting and has some icky patches.
< 1261866932 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :hm
< 1261866936 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :"Support for old Pentium 5 / WinChip machine checks"
< 1261866939 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :a kernel config option
< 1261866944 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :what the hell is a pentium 5
< 1261866960 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :ACTION looks at the score for Opus 9 in an attempt to judge its quality from just that.
< 1261867024 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :ACTION listens to the horrible-sounding MIDI version of Opus 9 instead.
< 1261867038 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :pentium 5fV
< 1261867051 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :er
< 1261867055 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :*5eV
< 1261867055 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Why am I listening to this at all? It's not for piano.
< 1261867123 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :oerjan, what?
< 1261867135 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :uorygl, why is it horrible sounding?
< 1261867150 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :uorygl, not a good enough sound font loaded into your hardware midi?
< 1261867182 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :oerjan, thing is, if this is a typo for pentium 3 then it would affect the kernel I'm configuring
< 1261867262 0 :augur!unknown@unknown.invalid QUIT :"Leaving..."
< 1261867306 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :oh it seems the original pentium was codenamed P5
< 1261867307 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: punny puns of puun
< 1261867308 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :that explains stuff
< 1261867316 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :meh
< 1261867328 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :oerjan, too worried about this to bother with puns
< 1261867362 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: nope. It's probably difficult to get a good soundfont for a string trio.
< 1261867367 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :and I'm not in a happy mood atm: frozen water in pipes tends to make you rather unhappy
< 1261867380 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :eek
< 1261867398 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :oerjan, thankfully only for the garden hose connection on the outside of the wall
< 1261867413 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :so no expensive leak inside some wall
< 1261867420 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :but still, water has to be turned off
< 1261867431 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :until a plumber is available
< 1261867433 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :and they are hard to get
< 1261867466 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :not a single one within 40 km radius was able before tomorrow (and this happened yesterday morning)
< 1261867566 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :mhm
< 1261867610 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :btw googling for pentium 5 found some funny old stuff
< 1261867623 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :rumours about a 15 GHz pentium 5 by 2010 for example :D
< 1261867628 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :was from 2002
< 1261867660 0 :MigoMipo!n=MigoMipo@84-217-5-116.tn.glocalnet.net JOIN :#esoteric
< 1261867827 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :AnMaster: Well, Intel did say they were going to go to 10 GHz and higher, around the time when the Prescott came out
< 1261867843 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :When they noticed AMD's 2 GHz chips performed better than theirs they kinda changed plans
< 1261867864 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :(Where "theirs" == 5 GHz and up.)
< 1261867866 0 :augur!n=augur@c-71-196-120-234.hsd1.fl.comcast.net JOIN :#esoteric
< 1261867971 0 :Deewiant!unknown@unknown.invalid PRIVMSG #esoteric :http://en.wikipedia.org/wiki/Tejas_and_Jayhawk suggests they had 7 GHz stuff ready to be built in 2004.
< 1261868639 0 :Asztal!unknown@unknown.invalid QUIT :Read error: 60 (Operation timed out)
< 1261869575 0 :soupdragon!n=somebody@unaffiliated/fax JOIN :#esoteric
< 1261869802 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :heh
< 1261869823 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :Deewiant, but I thought there was some wall around 5-6 Ghz?
< 1261869824 0 :AnMaster!unknown@unknown.invalid PRIVMSG #esoteric :iirc
< 1261870164 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :What was the highest clock frequency seen in any sold Intel X86/X64 series processor?
< 1261870614 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :hiya
< 1261870620 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :I wanted to ask you guys a question here
< 1261870664 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :Given a linear recurrence over the integers: a_n = c_1 * a_(n-1) + ... + c_d * a_(n-d)
< 1261870690 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :with initial conditions, does there exist an k so that a_k = 0? He only asks for a decision procedure: he says that it is ... faintly outrageous that this problem is still open; it is saying that we do not know how to decide the halting problem even for “linear” automata!
< 1261870710 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :Apparently 3.8GHz was the highest.
< 1261870722 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :doh
< 1261870725 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :I just realized
< 1261870743 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :I was going to ask, doesn't rule 110 explain why there is no decision procedure
< 1261870750 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :but actually it's not a linear recurrence..
< 1261870758 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :so nevermind
< 1261870801 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :That question is reminiscent of the subset-sum problem.
< 1261870824 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon: um that looked linear to me...
< 1261870838 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Rule 110 looks linear?
< 1261870844 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :oh, no.
< 1261870868 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :I think that linear recurrence plus initial conditions decision looks solvable...
< 1261870919 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon: "faintly outrageous that this problem is still open" means that whoever gave you the problem claims it's open?
< 1261870925 0 :uorygl!unknown@unknown.invalid PRIVMSG #esoteric :Hmm, all those linear recurrences can be represented as matrices.
< 1261870925 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :Ah yeah, I figured out what the problem is...
< 1261870970 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :yes the claim is that it's open, and I thought 110 gave an argument against: but then realized that 1D CA is a different format
< 1261870986 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :hm
< 1261871020 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :a_n = c_1 * a_(n-1) + ... c_d * a_(n_d) plus initial conditions can be written in form a_n = e_1 * (b_1)^n + ... + e_d * (b_d)^n.
< 1261871024 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well that obviously means it's _hard_
< 1261871076 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :Ilari: that may still make it _worse_, since those b_i are not integers
< 1261871079 0 :MigoMipo!unknown@unknown.invalid QUIT :Read error: 60 (Operation timed out)
< 1261871095 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: In fact b's and e's are not even guaranteed to be real.
< 1261871105 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :right.
< 1261871217 0 :MizardX!unknown@unknown.invalid QUIT :"zzz"
< 1261871230 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :so you can't encode a turing machine with a linear recurrence?
< 1261871403 0 :adu!unknown@unknown.invalid QUIT :Read error: 110 (Connection timed out)
< 1261871503 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :soupdragon: um if we knew how to do that we would have solved that unsolved problem. you think that is something done on the spot in an irc channel?
< 1261871515 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :haha
< 1261871531 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :if you know you can't encode a turing machine into the linear recurrence, it still doesn't solve the problem
< 1261871553 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :hm could be
< 1261871567 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :if you know you can then the problem is closed, but it's open -- so there's some kind of epistomogical argument that you can't encode turing machines into it
< 1261871576 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :er epistemological
< 1261871596 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :QED! :P
< 1261871615 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i don't think so. it could just be possible, but very hard
< 1261871639 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :that's how famous unsolved problems are usually solved, after all
< 1261871666 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well that or someone comes up with an argument from something completely unrelated
< 1261871689 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :or both.
< 1261871765 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :it can be easily turned into a number of special cases of a vector problem
< 1261871794 0 :Ilari!unknown@unknown.invalid PRIVMSG #esoteric :Here's another problem that's suprisingly hard (but not unsolveable): Given nxn table of bits, How many ways there are to choose n all-1 bits such that no two chosen bits are on same column or row?
< 1261871794 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :given matrix A, vector v, is there any n such that A^n v has first coordinate 0
< 1261871832 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :although that could still be harder, or could it...
< 1261871865 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :Ilari, <= n! I guess
< 1261871885 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well that's obviously solvable in the computational sense, just use brute force
< 1261871892 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :^ Ilari
< 1261871903 0 :soupdragon!unknown@unknown.invalid PRIVMSG #esoteric :oerjan, hm.. I have seen people compute fibs using the matrix power like that so yeah I see a link