## Transform an SQL command into Lambda or Java 8 Stream

I am starting Java 8 and would like to convert the command in SQL down to a lambda function:

``````SELECT * FROM Correspondence Candidate c, (SELECT entityOrigin, MAX (m1)
SimilarityMaxima FROM Correspondence Candidate WHERE m1 <> 0 GROUP BY
(in the event of an error)
r.similaridadeMaxima
``````

I created the class `correspondence` with `collectors` Y `set`.

public class Correspondence {

``````int code;
Chain name;
String entityOrigin;
String EntityDestination;
double m1;
double m2;
double m3;
double medMax;
double dem;

public int getCodigo () {}
return code;
}
public void setCodigo (int code) {
this.codigo = code;
}
public String getName () {
return name;
}
public void setName (string name) {
this.name = name;
}
public String getEntidadeOrigen () {
return entityOrigin;
}
public void setOriginEntity (String entityOrigin) {
this.setOrder = entityOrigin;
}
public String getEntidadeDestino () {
return Target Entity;
}
public void set EntityDestin (String EntityDestin) {
Target Entity = Target entity;
}
public double getM1 () {
return m1;
}
public void setM1 (double m1) {}
this.m1 = m1;
}
public double getM2 () {
return m2;
}
public void setM2 (double m2) {}
this.m2 = m2;
}
public double getM3 () {
return m3;
}
public void setM3 (double m3)
this.m3 = m3;
}
public double getMedMax () {
return medMax;
}
public void setMedMax (double medMax) {
this.medMax = medMax;
}
public double getDem () {}
return dem;
}
public void setDem (double dem)
this.dem = dem;
}
``````

## c # – Sort by alphabet letters A-L and M-Z using lambda

Good day,

In my example case, I am trying to get all the users of my database and place them in my store where I have sorting lists by alphabet letters given the following: A-L, M-Z

Here is my sample code with common `OrderBy` by the username:

``````var users = await users.Users (). ToListAsync ();

return users.Select (u => new CategorizedByLetterUserDto {
...
}). OrderBy (u => u.Name);
``````

Then my sample `CategorizedByLetterUserDto` It looks like this.

``````public class CategorizedByLetterUserDto {
IEnumerable public AtoL {get; set}
IEnumerable public MtoZ {get; set;}
...
}

public class AtoL {
Public ID int {get; set;}
Name of the public string {get; set;}
}

public class MtoZ {
Public ID int {get; set;}
Name of the public string {get; set;}
}

so on ...
``````

So the result will be (array).

``````    {
categorizedByLetterUserDto: {
atoL: [
{
...
}
],
mtoz [
{
...
}
]
}
}
``````

## graphic isomorphism – Are the lambda expressions isomorphic (without type) semantically equivalent?

"Isomorphic" is defined as having the same form of syntax trees and the same variable links. However, the names of the variables can be completely different. In other words, it is to say that we have a graphical isomorphism between the two expressions (the graph is the syntax tree with the variable link included as edges).
The intuition behind this is that assuming we are given the isomorphism, it is always possible to change the name of the variables and get the other expression.

## Lambda calculation – Is the discrete function also a mathematical function?

Here is a table from the Staten Island subway:

``````| For | STATION |
| ------ + ----------------- |
| 1 | Saint George |
| 2 | Tomkinsville |
| 3 | Stapleton |
| 4 | Clifton |
| 5 | Grasmere |
| 6 | Old town |
| 7 | Hills of Dongan |
| 8 | Jefferson |
| 9 | Grant |
| 10 | New Dorp |
| 11 | Oakwood Heights |
| 12 | Bay Terrace |
| 13 | Big murders |
| 14 | Eltingville |
| 15 | Annadale |
| 16 | Hugenot |
| 17 | Prince & # 39; s Bay |
| 18 | Pleasant plains |
| 19 | Richmond Valley |
| 20 | Arturo killing |
| 21 | Tottenville |
``````

and here is an Elisp function that assigns a number to a name:

``````(Defun sisubstops (s)
(case s
((pred (or (< s 1) (> s 21))) (message "Hey, just stop between 1 and 21, please!"))
(& # 39; 1 (message "Saint George"))
(& # 39; 2 (message "" Tomkinsville))
(& # 39; 3 (message "Stapleton"))
(& # 39; 4 (message "Clifton"))
(& # 39; 5 (message "Grasmere"))
(& # 39; 6 (message "Old Town"))
(& # 39; 7 (message "Dongan Hills"))
(& # 39; 8 (message "Jefferson"))
(& # 39; 9 (message "Grant"))
(& # 39; 10 (message "New Dorp"))
(& # 39; 11 (message "Oakwood Heights"))
(& # 39; 12 (message "Bay Terrace"))
(& # 39; 13 (message "Great Kills"))
(& # 39; 14 (message "Eltingville"))
(& # 39; 15 (message "Annadale"))
(& # 39; 16 (message "Hugenot"))
(& # 39; 17 (message "Prince & # 39; s Bay"))
(& # 39; 18 (message "Pleasant Plains"))
(& # 39; 19 (message "Richmond Valley"))
(& # 39; 20 (message "Arthur Kill"))
(& # 39; 21 (message "Tottenville"))))
``````

So, when I try to tell the students that this is a function of a basically non-continuous phenomenon, that is, we are not dealing with a function like `f (x) = x ^ 2`, rather a function that matches the stops with the names but it's still a function – How can I transmit this? One idea would be to delve into Lambda Calculus and talk about how LC makes conditional. My first objective is to distinguish between continuous versus discreet; and yet, I've written a Lisp function that can not really be represented as any kind of normal mathematical function, for example, `S (n) = M * n`where `SUBWAY` is a type of machine or constant that takes a stop number and converts it into a stop name. Any idea how, yes, this is a function? Or is this just a misnomer, that is, comp-sci using / abusing the term function. So, how are you? `sisubstops` Really a function?

## Lambda calculation: continuations delimited by multiple warnings in terms of continuations delimited by a single warning

Let's call the two languages ​​in question (untyped lambda calculation with continuations delimited by single or multiple request) L_delim and L_prompt.

Is it possible to express delimited continuations of multiple requests in terms of delimited continuations of a single application?

By express I mean the macroexpressible meaning (to provide some kind of translation that does not involve an overload of the interpreter), of course, it is possible to write an interpreter for delimited continuations of multiple indicators even in pure lambda calculus.

I expected a negative result for this, which is not possible but I do not know how it would be shown. Thanks for any input on this.

## real analysis: show that \$ f_n (x) = x ^ ne ^ {- x ^ 2}, n≥0 \$ convergence in \$ L ^ p ( lambda, R) \$

Question:
Show that

$$f_n (x) = x ^ ne ^ {- x ^ 2}, n≥0$$ convergence in $$L ^ p ( lambda, R)$$ where $$lambda$$ Measurement of Lebesgue

My intent:
$$x to x ^ ne ^ {- x ^ 2}$$
Measurable application as continue

Next: try: $$int_ {R} | x ^ ne ^ {- x ^ 2} | d lambda <{+ infty}$$

$$there is m$$ such that $$e ^ {- x ^ 2} ≤ frac {m!} {x ^ {2m}}$$
Then take integral $$int_0 ^ 1 + int_1 ^ {+ infty}$$
I need a solution without a gamma function.

## What does it mean that by saying "we want \$ Lambda \$ to be \$ tilde {O} (1) \$ based on \$ M \$"?

What does it mean to say "we want" $$Lambda$$ be $$tilde {O} (1)$$ as a function of $$M$$"? (appears at the top of page 12 of this document)

## API based on AWS Lambda using django – pros / cons?

Is it a better architecture to use the Django framework in the API configuration based on the lambda gateway / AWS API? What are the benefits we can obtain with such an architectural choice? Will you make the lambda response a little slower?

## C ++ Generic class receiving lambda and struct function

Dear,

I'm trying to do some things in C ++, but I'm still starting both in the language and in the functional paradigm. What I need is to insert a function `lambda` a `pair`. The first member of the Council `pair` it will be an object `struct`, and the second, the lambda function. My lambda function returns receives as parameters a `struct` is a `vector` and returns a `chain`, Something like:

``````auto lambda = [](struct & s, vector & V) {
return (s.attribute + "" + v[0]);
};
``````

In that case, `pair` It would be something like:

``````pair nominal;
``````

I already encountered many type errors (when I was trying to insert the lambda function into a `Map`and in the search for a solution, I found something that I can solve: a generic class that surrounds the lambda functions and that has a method of executing the lambda function. I found an example of generic class for that, but because of my ignorance of the language, I do not know how to change it to accept lambda functions with parameters (without capture):

``````class T {v}
private:
double (* expression) ();
public:
T (double (* exp) ()): expression (exp) {}
double executes () {
return this-> expression ();
}
};

int main () {} ()
T t ([]() -> double {return 1 + 1;});
double val = t.execute (); // val = 2
return 0;
}
``````

In addition to changing the types `double` for `chain`, What more precise change in the class to receive lambda functions with parameters (no capture, only parameters)? The idea is that the T types are created in this way:

``````T t ([](struct & s, vector and v) -> string {
return (s.attribute + "" + v[0]);
});
``````

And run like this:

``````string text = t.execute (struct, vector);
``````

That's possible? And most importantly, it will be possible to insert this type T into `pair`?

I appreciate any help.

## c # – LINQ or Lambda for two foreach queries

The code I have written works well, this research is purely for educational purposes. I want to know how others would do it better and cleaner. I especially hate the way I use two loops to get data. There has to be a more efficient way.

I have a table of document names in my SQL database and files in the content folder.
I have a list of two: ListOfFileNamesSavedInTheDB and ListOfFileNamesInTheFolder.

Basically, I'm getting all the names of files saved in the database and checking if it exists in the folder, if I do not delete the file name of the database.

``````    var clientDocList = documentRepository.Documents.Where (c => c.ClientID == clientID) .ToList ();

if (Directory.Exists (directoryPath))
{
rope[] fileList = Directory.GetFiles (directoryPath) .Select (Path.GetFileName) .ToArray ();
bool fileNotExist = false;
foreach (var file in fileList)
{
foreach (var clientDoc in clientDocList)
{
if (clientDoc.DocFileName.Trim (). ToUpper () == file.ToUpper (). Trim ())
{
fileNotExist = false;
break;
}
}

yes (fileNotExist)
{
// Delete the name of the database file
}
}
}
``````