mdrslmr @mdrslmr@qoto.org

@sothawo @tante
Danke für den Tip. Ich denke die Position ist sicher richtig. Aber vielleicht auch ein wenig "Video kills the radio star "?
Also auch als Taschenrechner eingeführt wurden haben wir Kopfrechnen weniger gut gelernt, ... usw. Aber sicher, der enorme Energieverbrauch für Zeug das niemand braucht, ist natürlich nicht verantwortbar.

@kosmikus
Your solution is much better than mine.
It dose not need to construct tree (nodes) and it does not reorder the nodes if doing something like this:
"
rlisttree :: Tree a -> [a]
rlisttree = redtree (:) (++) []
"

@kosmikus
I didn't know there where different versions of the paper. Cool, yes this way the types of the functiobs are uniquely defined Thanks.

There was a post pointing to the beautiful more than 30 years old #functionalprogramming paper "Why Functional Programming Matters" John Hughes. I could not find the post again to reply,

The paper gives a definition of "foldtree" on page 7:
"
foldtree f g a (Node label subtrees) =
f label (foldtree f g a subtrees)
foldtree f g a (Cons subtree rest) =
g (foldtree f g a subtree) (foldtree f g a rest)
foldtree f g a Nil = a
"

I wonder what the type of "foldtree" could be. Since the last argument
is "treeof ∗" in the first declaration but "(listof (treeof ∗)" in the second.

In #haskell I would implement it as:

data Tree a = Node a [Tree a]

foldtree :: (a -> b -> b) -> (b -> b -> b) -> b -> Tree a -> b
foldtree f g a (Node x []) = f x a
foldtree f g a (Node x (t:ts)) =
g (foldtree f g a t) (foldtree f g a (Node x ts))

But probably I'm miss something here, since it takes only two declarations.

I have moved this little project to:

https://github.com/mdrslmr/MultipletCombiner

https://hackage.haskell.org/package/MultipletCombiner

https://aur.archlinux.org/packages/haskell-multipletcombiner

#haskell
#physics
#grouptheory
#math
#functionalprogramming

@apodoxus @philosophy
I like the idea about time split at the big bang. I wonder how this relates to the interpretation in QFT of anti particles as particles traveling backwards in time?

It is probably a bad idea in #Haskell,
but still surprising: #ghc does not
complain about using "do" to define (>>=) itself.
It seams to cause and endless loop.

newtype BadIdea a = B a
        deriving Show

instance Functor BadIdea where
        fmap f (B a) = B (f a)

instance Applicative BadIdea where
        pure x = B x
        (B f) <*> B x = B (f x)

instance Monad BadIdea where
        return x = B x
        ma >>= f = do
                 a <- ma
                 f a
-- instead of
--        (B a) >>= f = f a

main = print
        (B 5 >>= (\x -> B (2*x)))

@wactbprot
Yes great lecture about #lambda calculus and #functionalprogramming.

When I tried to program the AND combinator in #haskell I failed. Maybe because of the static type system but more likely because of my inability?

Is there a simple solution for AND: (\p q -> p q p ) in #haskell?

This is as far as I got:

tr :: a -> b -> a
tr = \p q -> p
fs :: a -> b -> b
fs = \p q -> q

and' = \p q -> p q fs
or' = \p q -> p tr q
-- ghci> or' tr fs True False
-- True
-- ghci> and' tr fs True False
-- False

-- and'' = \p q -> p q p -- does not work
-- or'' = \p q -> p p q -- does not work

@ctsystems@noagendasocial.com
Everywhere and nowhere. Think of the 2d space of a balloon, getting blown up. Where is the center on the surface?

@wactbprot
Yes excellent, thanks.
When I tried to programm the and combinator in haskell I failed. Maybe because of the static type system but more likely because of my inability?

Any simple solution for and (\p q -> p q p ) in haskell?

Not new but still the best 2 minutes , well, sketch of the
Brout-Englert-Higgs
#Higgs mechanism I know. #Particles #CERN #Physics
https://m.youtube.com/watch?v=qIXpTIVFF7I

In my spare time I learned a bit about #Haskell and implemented an algorithm concerning multiplet combination, used in high energy #physics .
https://github.com/mdrslmr/Multiplet-Combining
It is a bit in between the fields of #Haskell #functionalprogramming , #physics and #grouptheory .