VegOwOtenks

joined 1 year ago
sorted by: new top controversial old
US Military never really trained for these types of dog and pony shows in c/whitepeopletwitter@sh.itjust.works
[–] VegOwOtenks@lemmy.world 3 points 2 weeks ago

I think this is what they are referring to: https://en.wikipedia.org/wiki/Broughton_Suspension_Bridge.

TL;DR: The bridge collapsed because soldiers marching on it created force they hadn't anticipated, soldiers breaking step supposedly don't have as much of an impact.

5
Issue 475 :: Haskell Weekly newsletter (haskellweekly.news)
 

Dear @Noughtmare@programming.dev, I want to thank you for your weekly post, I'm always happy to find a haskell newsletter in my inbox.
I hope you're not inconvenienced by me posting the newsletter link this week. I was looking for it and figured others might be doing the same, hence why I posted it.

Don't mind me, I've just been watching a lot of Doctor Rule in c/onehundredninetysix@lemmy.blahaj.zone
[–] VegOwOtenks@lemmy.world 7 points 3 months ago (1 children)

I also like watching Doctor Who, how did you manage to make a cute dalek? :d

When I try to go on a ricing journey again in c/linuxmemes@lemmy.world
[–] VegOwOtenks@lemmy.world 3 points 3 months ago (1 children)

The extension is called Burn-My-Windows and I always look forward to it when booting into GNOME because it feels so ✨fancy✨

When I try to go on a ricing journey again in c/linuxmemes@lemmy.world
[–] VegOwOtenks@lemmy.world 1 points 3 months ago

I stumbled over Gradience just yesterday but I tought it was archived sometime last year, is it still working accordingly?

When I try to go on a ricing journey again in c/linuxmemes@lemmy.world
[–] VegOwOtenks@lemmy.world 10 points 3 months ago

Unfortunately not :/ But I do have rainbow-gradient window borders.

When I try to go on a ricing journey again in c/linuxmemes@lemmy.world
[–] VegOwOtenks@lemmy.world 5 points 3 months ago (4 children)

I suppose you're mainly concerned about LibAdwaita-Apps?

When I try to go on a ricing journey again in c/linuxmemes@lemmy.world
[–] VegOwOtenks@lemmy.world 17 points 3 months ago (2 children)

I was surprised to learn that

  • a) macOS only recently added Left/Right-tiling natively (without extensions, just like GNOME does)
  • b) they leave gaps when you tile them so that it looks like you messed up the tiling somehow
578
When I try to go on a ricing journey again (lemmy.world)
 
Use monoids for construction, what does it do? in c/haskell@programming.dev
[–] VegOwOtenks@lemmy.world 3 points 4 months ago

Thank you for the detailed answer, especially the explanation 'in more words' and the link helped me understand what happens in this Monoid instance.

12
Use monoids for construction, what does it do? (lemmy.world)
submitted 4 months ago* (last edited 4 months ago) by VegOwOtenks@lemmy.world to c/haskell@programming.dev
2 comments fedilink
 

I consider myself to be learning haskell. I am proficient enough to solve Advent of Code and do some small projects using it. I love doing it but I always feel like there's more to it. Apparently there is: this blog post from Reasonably Polymorphic caught me, I was probably exactly the intended audience.

What's in the blog post?

They visualize the Builder Pattern, where an Object is created through repeated mutation, which, when transferred to Haskell, should be replaced by creating objects through Monoids and the corresponding Semigroup function <>.

I parse a programming language using parsec and I did exactly what was proposed to enhance my structure creation.

Before, my code was this

Old Code

data StructStatement = Variable VariableName VariableType
        | Function Function.Function

data Struct = Struct 
        { name :: String
        , variables :: [(VariableName, VariableType)]
        , functions :: [Function]
        }
        deriving (Show)

addVariable :: Struct -> VariableName -> VariableType -> Struct
addVariable (Struct sn vs fs) n t = Struct sn ((n, t): vs) fs

addFunction :: Struct -> Function -> Struct
addFunction (Struct sn vs fs) f = Struct sn vs (f:fs)

accumulateStruct :: Struct -> StructStatement -> Struct
accumulateStruct s (Variable n t) = addVariable s n t
accumulateStruct s (Function f)   = addFunction s f

Then using a fold over Struct _ [] [] (which is basically mempty I just realized) would get me the complete struct. It is kind of ugly:

foldl accumulateStruct (Struct structIdentifier [] []) <$!> braces (many structMember)

Now my code is this

New Code

data Struct = Struct
        { name :: String
        , body :: StructBody
        }
        deriving (Show)

data StructBody = StructBody
        { variables :: [(VariableName, VariableType)]
        , functions :: [Function]
        }
        deriving stock (Generic, Show)
        deriving (Semigroup, Monoid) via Generically StructBody

Which shorter and easier to use, the entire construction only looks like this now:

mconcat <$!> UbcLanguage.braces (many structMember)

I love the new construction method using Semigroup and Monoid. However, I don't understand them in depth anymore. I have written my own instance of Semigroup and Monoid, and I assume these deriving clauses do something similar.

Handwritten Semigroup instance

instance Semigroup StructBody where
  (<>) s1 s2 = StructBody
        { variables = variables s1 <> variables s2
        , functions = functions s1 <> functions s2
        }

Monoid instance is trivial then, just default all the values to mempty.

I also have a dump of the generated class instances using -ddump-deriv -dsuppress-all:

Generated instances

instance Semigroup StructBody where
  (<>) :: StructBody -> StructBody -> StructBody
  sconcat :: NonEmpty StructBody -> StructBody
  stimes ::
    forall (b_a87f :: *). Integral b_a87f =>
                          b_a87f -> StructBody -> StructBody
  (<>)
    = coerce
        @(Generically StructBody
          -> Generically StructBody -> Generically StructBody)
        @(StructBody -> StructBody -> StructBody)
        ((<>) @(Generically StructBody))
  sconcat
    = coerce
        @(NonEmpty (Generically StructBody) -> Generically StructBody)
        @(NonEmpty StructBody -> StructBody)
        (sconcat @(Generically StructBody))
  stimes
    = coerce
        @(b_a87f -> Generically StructBody -> Generically StructBody)
        @(b_a87f -> StructBody -> StructBody)
        (stimes @(Generically StructBody))

instance Monoid StructBody where
  mempty :: StructBody
  mappend :: StructBody -> StructBody -> StructBody
  mconcat :: [StructBody] -> StructBody
  mempty
    = coerce
        @(Generically StructBody) @StructBody
        (mempty @(Generically StructBody))
  mappend
    = coerce
        @(Generically StructBody
          -> Generically StructBody -> Generically StructBody)
        @(StructBody -> StructBody -> StructBody)
        (mappend @(Generically StructBody))
  mconcat
    = coerce
        @([Generically StructBody] -> Generically StructBody)
        @([StructBody] -> StructBody) (mconcat @(Generically StructBody))

In the documentation it says that there is an instance (Generic a, Monoid (Rep a ())) => Monoid (Generically a) which is defined exactly like the generated instance ghc dumped (source) which uses the Monoid of (Rep a ()) which isn't defined anywhere.

Where does the monoid come from? This is the generated type Rep

Generated

Derived type family instances:
  type Rep StructBody = D1
                          ('MetaData "StructBody" "Ubc.Parse.Syntax.Struct" "main" 'False)
                          (C1
                             ('MetaCons "StructBody" 'PrefixI 'True)
                             (S1
                                ('MetaSel
                                   ('Just "variables")
                                   'NoSourceUnpackedness
                                   'NoSourceStrictness
                                   'DecidedLazy)
                                (Rec0 [(VariableName, VariableType)])
                              :*: S1
                                    ('MetaSel
                                       ('Just "functions")
                                       'NoSourceUnpackedness
                                       'NoSourceStrictness
                                       'DecidedLazy)
                                    (Rec0 [Function])))

but I cannot find a Monoid instance. Do you know where I could learn about this?

Thank you for your time and attention

Edit: fixed a problem with a deriving clause, added a missing code block

Preliminary Leaderboard in c/advent_of_code@programming.dev
[–] VegOwOtenks@lemmy.world 1 points 6 months ago (1 children)

Not the first year I participate but the first year I finished, 2021 was my all-time high so far with 42 stars when I was just starting oit and learning python. Knowing that there were more people in the same boat and that there was a competition kept me going, although the competiton also induced a lot of stress, not sure whether I want to keep the competitive attitude.

Thanks to everyone for uploding solutions, Ideas and program stats, this kept me optimizing away, which was a lot of fun!

Preliminary Leaderboard in c/advent_of_code@programming.dev
[–] VegOwOtenks@lemmy.world 3 points 6 months ago (1 children)

I alwqys assumed you were Cameron Wu, who is?

🎄 - 2024 DAY 25 SOLUTIONS -🎄 in c/advent_of_code@programming.dev
[–] VegOwOtenks@lemmy.world 3 points 6 months ago* (last edited 6 months ago)

Haskell

Have a nice christmas if you're still celebrating today, otherwise hope you had a nice evening yesterday.

import Control.Arrow
import Control.Monad (join)
import Data.Bifunctor (bimap)
import qualified Data.List as List

heights = List.transpose
        >>> List.map (pred . List.length . List.takeWhile (== '#'))

parse = lines
        >>> init
        >>> List.groupBy (curry (snd >>> (/= "")))
        >>> List.map (List.filter (/= ""))
        >>> List.partition ((== "#####") . head)
        >>> second (List.map List.reverse)
        >>> join bimap (List.map heights)

cartesianProduct xs ys = [(x, y) | x <- xs, y <- ys]

part1 = uncurry cartesianProduct
        >>> List.map (uncurry (List.zipWith (+)))
        >>> List.filter (List.all (<6))
        >>> List.length
part2 = const 0

main = getContents
        >>= print
        . (part1 &&& part2)
        . parse
🤖 - 2024 DAY 24 SOLUTIONS - 🤖 in c/advent_of_code@programming.dev
[–] VegOwOtenks@lemmy.world 2 points 6 months ago (1 children)

Thank you for showing this trick, I knew Haskell was lazy but this one blew my mind again.

73
Is there any security in the communication with Voyager I? (lemmy.world)
submitted 6 months ago* (last edited 6 months ago) by VegOwOtenks@lemmy.world to c/nostupidquestions@lemmy.world
23 comments fedilink
 

I mean the Voyager 1 probe which is currently the human-made object the farthest away from earth. The space program people operating the mission seem to have great control options, they even "moved software from one chip to another" (link) Apart from the probably gigantic and expensive installation needed to receive and/or send messages from/to that far away from home (23 hours of delay?), are there any safety measures to prevent a potentially malicous actor from sending commands to the probe?

19
What is your favourite matrix client? (lemmy.world)
 

Up until now I simply used Element, it just works and it doesn't look too bad. Unfortunately, I now have two Matrix accounts, my personal account and the account my university automatically created on their own matrix instance.
I need to communicate using both my accounts now, but Element couldn't handle two accounts at the same time, so I went on to install a second client, Fractal, which also supports multiple accounts. However, I am somewhat unhappy with Fractal because I cannot select text in messages.

Please share your experiences and recommendations with or on matrix clients.

154
Mayonnaise is not a dressing (lemmy.world)
 
-28
Quit Windows Fun Now (lemmy.world)
 
223
TemporalAccessor, TemporalAdjustor could just as well be Star Trek things (lemmy.world)
 
392
Regex flavors (lemmy.world)
 
204
What Parity Flag is that? (lemmy.world)
 
222
getsockname() (lemmy.world)
 
view more: next ›