In D&D 5e, as a Pact of the Chain Warlock, I can choose an eldritch invocation that lets me speak in my own voice through my familiar called Voice of the Chain Master (PHB 111):
You can communicate telepathically with your familiar and perceive through your familiar’s senses as long as you are on the same plane of existence. Additionally, while perceiving through your familiar’s senses, you can also speak through your familiar in your own voice, even if your familiar is normally incapable of speech.
Healing word is a spell with only a verbal component (PHB 249):
A creature of your choice that you can see within range regains hit points equal to 1d4 + your spellcasting ability modifier.
The description of verbal components in the rules of spellcasting (PHB 203) says the sound of my voice alone is what causes the magic of this spell to happen:
Most spells require the chanting of mystic words. The words themselves aren’t the source of the spell’s power; rather, the particular combination of sounds, with specific pitch and resonance, sets the threads of magic in motion.
Say my familiar is in another room, no matter how far away. Through my familiar’s eyes, I see a target at 60 feet. From my familiar comes my own magic-infused voice. That particular combination of sounds, with specific pitch and resonance, sets the threads of magic in motion that travel to the target and heal it.
Is this possible?
CPU’s are to an extent designed with in mind the software that people will write for it, implicitly or explicitly.
It seems to me that if you look at the design of instruction set architectures, they are very “imperative”, in the sense that each instruction encodes an imperative style command. It also seems to me that the current instruction set architectures have evolved partly based on the type of code programmers produce.
If one would design a CPU from scratch, knowing that it would only ever run programs written in a functional programming style, how would that CPU be designed differently from existing CPU’s?
I’ve been reading for a few weeks about the Lambda Calculus, but I have not yet seen anything that is materially distinct from existing mathematical functions, and I want to know whether it is just a matter of notation, or whether there are any new properties or rules created by the lambda calculus axioms that don’t apply to every mathematical function. So, for example, I’ve read that:
“There can be anonymous functions” -> Lambda functions aren’t anonymous, they’re just all called lambda. It is permissible in mathematical notation to use the same variable for different functions if the name is not important. For example, the two functions in a Galois Connection are often both called *
“Functions can accept functions as inputs” -> Not new you can do this in with ordinary functions.
“Functions are black boxes” -> Just inputs and outputs are also valid descriptions of mathematical functions…
This may seem like a discussion or opinion question but I believe that there should be a “correct” answer to this question. I want to know whether lambda calculus is just a notational, or syntactic convention for working with mathematical functions, or whether there are any substantial or semantic differences between lambdas and ordinary functions.
Is there any problem that can be only solved with recursion, and not with iteration? (haven’t been able to find anything online).
If there isn’t any, is there a reason why?
Thanks in advance!
I am used to implementing algorithms in imperative languages. Many of the algorithms I have implemented use hash maps, hash sets, mutable arrays, heaps, doubly linked lists, etc. I understand that some of the data types don’t exist in functional languages. For example, it may be hard to implement hash data structures or mutable arrays.
With that in mind, is purely functional programming in some situations algorithmically more expensive than imperative programming? For example,
- If I want to implement timer heap with O(1) peeking of next timer to expire, O(log N) removal of next timer to expire, O(log N) addition of new timer, O(log N) removal of arbitrary timer and O(log N) adjustment of timer expiration time, can I implement the timer heap in a purely functional programming language?
- If I want to implement a timer wheel, can I do so in a purely functional programming language?
- If I want to implement O(1) lookup in a set or a map, meaning in practice hash structures are needed, can I do so in a purely functional programming language?
- If I want to implement a ring buffer for efficient communication between threads in a producer-consumer pattern, can I do so?
- If I want to maintain a a list of free TCP ports in a firewall, doubly linked list would be a suitable O(1) data structure for that, allowing O(1) removal of an arbitrary port, but can I do so in a purely functional language?
- If I want to have a fast and efficient O(1) bit set, can I have such a construct in a purely functional language?
Note I’m not interested in large vs small constant in the runtime. I’m interested in runtime becoming fundamentally different, e.g. O(log N) instead of O(1). Of course functional algorithms may be less efficient due to the extra overheads of added abstraction in terms of runtime constant.
Some programming languages, apart from functions, have generators (eg. Python’s yield). Although generators are introduced in this Python’s tutorial on functional programming, I don’t think that they can be considered functional programming, because they do have state, and in a vary implicit manner.
Generators are reminiscent of laziness in pure functional languages like Haskell. Apart from laziness, are there other purely functional alternatives for having a construct similar to generators? Do you have any examples?
For a long time, the use of these Monad structures has been restricted to a very small circle of languages, many of them purely functional (mainly due to problems related to the management of the IO).
Recently, these structures have also been adapted to imperative languages
My question is: we talk about same design pattern, Monad, but what is the difference in the implementation of a monad in a purely functional language with respect to the same design pattern but implemented into of the imperative programming ?
What change? Sure not change the idea, but if we talk about of same design pattern implementation but into 2 different programming paradigm something must be different, probably the same information will come back, but we are using identical idea but in 2 different paradigms contexts so the side effect cannot be the same otherwise it would not have occurred to us to implement the monad for imperative language
Let $ F$ be a field, $ I$ a set, and $ U$ an ultrafilter on $ I$ . Is the ultrapower $ \prod_U F$ a purely transcendental field extension of $ F$ ?
According to Chapter VII, Exercise 3.6 from Barnes, Mack “An algebraic introduction to mathematical logic” the answer is apparently yes, but how does one actually show this?
I am happy to assume additional conditions on the ultrafilter if that helps.
For a B2B web app we are designing, we have a select box with a dropdown to select values from which are essentially tags. A user can select from an existing list of tags but they can not create a custom tag. Tags are added by a different user and are not too frequently updated. There is no upper limit on the total number of tags this dropdown can have but there is a lower limit of at least 1 tag to select from.
There are two design patterns which we are trying to explore, but we are not able to figure out which one to use/which one would be better for our users in both, short and long-term. We expect our users to interact with this UI component at least a few times a week.
Pattern 1) We show a drop-down with a placeholder text, ‘Select From Tags Below’ > On click of this field, we show the drop-down with all the available tags to choose from. We will add a Search provision inside the dropdown to allow the user search for a particular tag in the list:
Pattern 2) We show a searchable input field with a placeholder text ‘Type to Search or Select Tags’ > On click of this field, we show the drop-down with tags in alphabetical order > As user types the tags name, we show the tag in the dropdown list > User selects the value > Types the next tag value or scrolls through the dropdown to find and select the tags he would like to add.
This can be useful if the user knows the names of the tags he wants to add. But at the same time, is mostly used – in other apps we researched – where the user can add a value as per his/her will (custom tags/values), which we do not have.
Question: Which interaction pattern would be better in your opinion/experience and why?