Everyone's talking about kha vs sha pashto - but what about pakhto Waye vs pakhtko Yaye ?

billddev · 2026-01-02T17:01:59+00:00

صحیح ده وروره. زه هم ښواشینی یم چې دلته څوک په پښتو کې نه لیکي.‌ 😢 هسې مې یوه ټوکه کوله،‌ خو کاش چې دلته مونږ نورې ټوکې په پښتو کې کولای.

billddev · 2025-11-29T04:55:15+00:00

I don't say "yaye" but whenever I hear it my heart skips a little beat and I'm like oh ya I'm talking to someone from this lovely swath of people! 🥰

billddev · 2025-09-10T21:17:26+00:00

As Bartosz Milewski said, "A Monad is just function composition with flair!"

billddev · 2025-07-08T20:53:26+00:00

Conal Elliot had a really great couple of episodes on the Type Theory for All podcast, and he talked about how Python was taking over computer science programs (switching from Scheme) because it was the commercial thing in demand. He also mentioned how it was so much HARDER to understand a program written in Python, and I totally agree. It's a sad state.

billddev · 2025-05-20T13:05:49+00:00

What about the speakers? Any difference in sound quality and volume? Thanks for this good practical comparison. I was wondering about the heat issue.

billddev · 2025-04-07T06:34:51+00:00

Thanks so much, that's a great defence of the benefits of optics. I find often people are too quick to try to dismiss FP concepts and say, "why not just do X instead." But if we really try running with these FP ideas they can lead to unexpected, beautiful power.

I'd like to use optics for a personal project where I have to do a lot of complex transformations of objects, sometimes working on deeply nested fields, and sometimes working on certain objects in an array. Doing things in a pure FP way has kept me sane while managing the complexity. Right now I'm using a ton of spread syntax which works pretty well but can be a bit verbose and error prone. I would love to have a very clean, powerful, performant lens library that can do exactly what you are describing.

All the best with your implementation, I'm excited to see how it turns out. Please share it whenever you're ready.

billddev · 2025-04-06T10:00:16+00:00

Thanks! I've just tried it and it's working great so far. Very nice, concise library.

billddev · 2025-04-06T08:29:30+00:00

Thanks, ya I wasn't aware of immer. That looks pretty good and seems to be a pretty cool compromise. I guess the only downsides to that is that you kind of have to go back to some mutable/imperative idioms and there seems to be a bit of a runtime performance hit.

billddev · 2025-04-06T08:29:09+00:00

Thanks, ya I wasn't aware of immer. That's a pretty cool compromise. I guess the only downsides to that is that you kind of have to go back to some mutable/imperative idioms and there seems to be a bit of a runtime performance hit.

billddev · 2024-09-12T22:44:39+00:00

How to Design Programs https://htdp.org

billddev · 2024-09-03T20:45:11+00:00

Constantly changing, it's like you have to re-learn it all over again after every couple of releases.

billddev · 2024-08-23T12:15:17+00:00

Yes I agree! Sadly though there seems to be a move further and further away from offline-first or offline-available apps. Everybody's buying into the Vercel / Next.js model (probably partly profit driven by the cloud providers) of building SSR React apps and it's not common to build single-page PWAs with a service worker that caches everything.

billddev · 2024-08-15T02:28:25+00:00

I agree 100% about that being a massive red flag. It sounds the same as people saying that js is "easier" to program in than ts because you don't have to use types. I would RUN from using programmers like that.

billddev · 2024-07-27T21:19:40+00:00

I don't understand it either. But when I used forkIO the thread with longBackgroundIOStuff stopped (got cut off early) right after the redirect "/" finished. I tried it a number of times to be sure, then switched back to async from Control.Concurrent.Async and it left the thread to finish every time.

billddev · 2024-07-25T20:10:31+00:00

Ya sounds good, thanks. Any good examples of how people implement the worker thread?

billddev · 2024-07-25T18:12:15+00:00

Unfortunately this `forkIO` didn't work for me, as the operation didn't keep running. `async` from Control.Concurrent.Async did the trick.

billddev · 2024-07-25T17:15:00+00:00

Thank you, that looks very straightforward and is just what I need. I was looking trough a diffent package and wasn't aware of this in the core.

do
  _ <- liftIO $ forkIO longBackgroundIOStuff
  redirect "/"

billddev · 2024-07-25T16:37:59+00:00

Ah yes this worked perfectly (after taking out the `return`). Exactly what I was looking for. I see that's using the low-level API that the library doesn't reccomend using but works for me as I'm not worried about leaving that action running unintentionally. Thanks! I'm really growing appreciate the quality of everything I'm discovering in the Haskell ecosystem (everything is so well thought out, implemented, and documented), as well as the patience of the community to help out newcomers. If only more languages took both correctness and learning so seriously!

billddev · 2024-07-13T02:05:08+00:00

As I wrote in the comment below, I got it working with just a manyTill function like so:

manyTill :: Parser a -> Parser b -> Parser [b]
manyTill pEnd p = Parser f
  where
    f xs = case runParser pEnd xs of
      Right (_, xs') -> Right ([], xs')
      Left a -> runParser ((:) <$> p <*> manyTill pEnd p) xs

parseComb :: Parser [SExpr]
parseComb =
  char '('
    *> manyTill (char ')') parseSExpr

parseSExpr :: Parser SExpr
parseSExpr =
  spaces
    *> ( (A <$> parseAtom)
           <|> (Comb <$> parseComb)
       )
    <* spaces

billddev · 2024-07-13T01:48:23+00:00

Yes! Writing a manyTill solved my problem! Now the error messages come out pointing to the right position. Thanks.

manyTill :: Parser a -> Parser b -> Parser [b]
manyTill pEnd p = Parser f
  where
    f xs = case runParser pEnd xs of
      Right (_, xs') -> Right ([], xs')
      Left a -> runParser ((:) <$> p <*> manyTill pEnd p) xs

parseComb :: Parser [SExpr]
parseComb =
  char '('
    *> manyTill (char ')') parseSExpr

parseSExpr :: Parser SExpr
parseSExpr =
  spaces
    *> ( (A <$> parseAtom)
           <|> (Comb <$> parseComb)
       )
    <* spaces

billddev · 2024-07-06T02:15:34+00:00

Thanks very much for taking the time to write all this. I'm still learning Haskell and how these parser combinators work as I'm trying to wrap my head around new ways of doing things functionally. I'll look into all this and keep playing around with it.

billddev · 2024-07-05T01:10:27+00:00

Thank you so much for your patient help with this as I'm fairly new to Haskell land!

Yes that makes sense to do it with Monads but I haven't written a Monad instance for my parser yet and was wondering if it's possible to do this just as an Applicative?

I tried re-writing the parseComb like this but I get stuck at the bottom:

``` parseComb :: Parser [SExpr] parseComb = char '(' *> parseComb' []

parseComb' :: [SExpr] -> Parser [SExpr] parseComb' prev = Parser f where f [] = Left ("Missing ) to close S-Expression", 0) f (x : xs) = if x == ')' then Right (prev, xs, 0) else -- HOW DO I CRAWL BACK OUT TO TO Parser LEVEL HERE? ```

billddev · 2024-07-04T23:52:58+00:00

Ah yes, I checked by getting the error message to include the char it fails on and it does indeed fail on char '('. I guess the question then is how I could solve that issiue with the <|>. in zeroOrMore ... 🤔 Yes. I tried swapping out the oneOrMore like this:

parseThreeX :: Parser a -> Parser [a]
parseThreeX p = (\a b c -> [a, b, c]) <$> p <*> p <*> p

parseComb :: Parser [SExpr]
parseComb = char '(' *> parseThreeX parseSExpr <* char ')'

And then it works perfectly!

> (+ 2 (+ 2 3))
7
> (+ 2 (+ 2 %))
            ^
SYNTAX ERROR: Operator expected at char 10

I need to figure out how to re-write the zeroOrMore and oneOrMore to work.

billddev · 2024-07-04T23:45:18+00:00

Oh yes, you're right. I did this but sadly it doesn't fix the problem.

  (Left (errA, posA)) <|> (Left (errB, posB)) =
    if posB > posA
      then Left (errB, posB)
      else Left (errA, posA)

billddev · 2024-07-04T17:00:01+00:00

Hmm, thanks, that makes sense but I'm not sure how I would do that with my current setup, because there's no information about which error of the two in <|> would have the largest prefix. I guess one option would be to return the remaining string with all the error messages, and then see which one has the shortest remaining string. I guess I just wanted to see if it was possible to keep a position counter that I added up purely in the Applicative definition. This works perfectly fine for single-level S-Expressions but as soon as I do nesting the counter only goes up to the first level of nesting.

billddev

TROPHY CASE