abides | ABIDES : Agent-Based Interactive Discrete Event Simulation

What is the point of making Functor a super class of Applicative and Monad. Both Applicative and Monad immediately imply the only implementation of Functor that abides by the laws as far as I can tell. But rather I have to type out the same implementation of Functor every time. Is there a way to avoid doing this?

Further more Monad implies the only implementation of Applicative that abides by the laws so why make Applicative a super class of Monad? Again it makes implementing Applicative for new data types redundant.

Is there a way to make a Monad without having to implement Applicative and Functor (as its operations are already the most general). And to make an Applicative without having to implement Functor.

I see the benefit of the class hierarchy as what I just said explains the "is a" relation between them. But at the same time having to implement each is annoying. I just want to define return and >>= and get all the operations of all 3 back.

How can one extend simply typed lambda calculus to have a type system that supports something like a monad type? Basically, I presently have a nice understanding of simply typed lambda calculus, and I'd like to understand the "minimal requirements" to add monads to that foundation. By "adding monads" I mean anything that would result in a language with an operational semantics and type assignment that allows one to recognize the "usefulness" of monads for programs, to some extent. For example, Haskell supports monads in reasonable sense even though it doesn't require the programmer to fully prove that their "monad" instance actually abides by the monad laws.

I'm hoping to understand some minimal way of extending STLC with monads in order to learn more about monads in relation to programming language theory. Personally, I find it easier to learn these things in a more stripped down/essential setting (as opposed to just using them in practice in a language like haskell). For this reason, I can't give any more of a precise description of what I'm looking for, than what I wrote above.

Edit, with regard to @Ben's comment: could you not have some kind of setup where you have a signature of "atomic" monads M, and then your simple types T are now:

T = σ | T₁ → T₂ | m T

where σ is an atomic type from the signature of atomic types, and m is an element of M.

And then maybe you also add constant terms to the lambda calculus terms:

t = x | t₁ t₂ | λ x.t | return t | t₁ >>= t₂$

I'm not sure if any of this would work, but it seems like something like this would be possible.

I'm trying to define a spec for a portion of the GraphQL schema syntax. Here's what a field type looks like as returned from an API (note that :ofType can be infinitely nested):

I am currently reading Effective Java and I am on the concurrency chapter. While explaining reasons a thread might wake up when a condition doesn't hold (condition of while loop in which a wait() call abides) there is one reason that is pretty confusing to me and I can't seem to understand it.

Another thread could have obtained the lock and changed the guarded state between the time a thread invoked notify and the waiting thread woke up.

Can someone try to explain this sentence?

The free monoids are often being regarded as "list monoids". Yet, I am interested in other possible structures which might give us free monoids.

Firstly, let us go over the definition of free monoids. I have never quite understood how is it possible to define a free monoid as a structure which abides by monoid laws and nothing else. How do we prove that something abides by no rules but stated above? Or is this just an intuition?

Anyway, we are going to speak functors. If some monoid is free, we got it with a free functor. It is obvious that a list comes in quite handy here:

I'm new to UI development so forgive me if this isn't angular. I'm using Angular 8 and typescript here. Anyways I created a pop-up modal that I wan't to use throughout my website. It looks great but when I plug it into my components like this

import { IPopUpOptions, IPopUpButton } from 'src/app/modals/pop-up-modal/pop-up-options-interface';

My SonarQube CI/CD pipeline says "Either remove this import or add it as a dependency. Dependencies should be explicitly listed in the package.json file. Importing a module that is not declared as a dependency makes it an implicit one and is bound to create problems." What does this mean? How can I use my pop-up properly so that it abides by this rule?